Skip to content

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

Integrate TV platform, playback, and UX improvements

Davidona04949b892706
diff --git a/README.md b/README.md
index a61b73ad..007d77f9 100644
--- a/README.md
+++ b/README.md
@@ -66,6 +66,12 @@ Android TV requires **explicit focus management**. Compose for TV handles much o
- **Favorites**: Stored locally in Room. Toggling a favorite is optimistic and instant in the UI.
- **Custom Groups**: Users can create custom "Virtual Categories" to organize channels.
+### πŸ“¦ TV Compose And Accessibility Tracking
+- `androidx.tv:tv-material` is intentionally pinned in `gradle/libs.versions.toml`.
+- The library is now stable, but `SearchScreen` still uses `FilterChip` APIs behind `ExperimentalTvMaterial3Api`.
+- Reduced-motion handling now respects Android's animator duration scale for shimmer and image crossfades.
+- See `docs/audit/tv-compose-accessibility.md` for the current migration risk and accessibility checklist.
+
---
## πŸš€ Getting Started
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 0f45a908..3ff5e917 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -94,6 +94,10 @@ dependencies {
// Media3
implementation(libs.media3.exoplayer)
+ implementation(libs.media3.exoplayer.hls)
+ implementation(libs.media3.exoplayer.dash)
+ implementation(libs.media3.exoplayer.rtsp)
+ implementation(libs.media3.datasource.okhttp)
implementation(libs.media3.ui)
// Room
@@ -133,6 +137,9 @@ dependencies {
// Core
implementation(libs.core.ktx)
implementation(libs.coroutines.android)
+ implementation(libs.appcompat)
+ implementation(libs.mediarouter)
+ implementation(libs.play.services.cast.framework)
// Test
testImplementation(libs.junit)
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
index 1ebfb9eb..431e72f0 100644
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@@ -31,6 +31,8 @@
-dontwarn org.conscrypt.**
-dontwarn org.bouncycastle.**
-dontwarn org.openjsse.**
+-keepnames class okhttp3.internal.platform.**
+-keepnames class okhttp3.internal.tls.**
# ── GSON ────────────────────────────────────────────────────
-keepattributes Signature
@@ -52,6 +54,13 @@
-keep class com.streamvault.data.local.entity.** { *; }
-keep class com.streamvault.data.remote.xtream.model.** { *; }
+# ── Security / TLS ──────────────────────────────────────────
+-keepnames class com.streamvault.data.security.CredentialCrypto
+-keepclassmembers class com.streamvault.data.security.CredentialCrypto {
+ <fields>;
+ <methods>;
+}
+
# ── Media3 / ExoPlayer ─────────────────────────────────────
# SEC-H01: Media3 ships its own consumer-proguard-rules.pro inside the AAR β€” no need
# for a broad keep here. Only explicitly keep classes loaded via reflection that the
diff --git a/app/src/androidTest/java/com/streamvault/app/tv/LauncherProviderInstrumentationTest.kt b/app/src/androidTest/java/com/streamvault/app/tv/LauncherProviderInstrumentationTest.kt
new file mode 100644
index 00000000..0b084d7a
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/tv/LauncherProviderInstrumentationTest.kt
@@ -0,0 +1,255 @@
+package com.streamvault.app.tv
+
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.content.ContentValues
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.media.tv.TvContract
+import android.net.Uri
+import android.os.Build
+import android.provider.BaseColumns
+import android.util.Log
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.UUID
+
+@RunWith(AndroidJUnit4::class)
+class LauncherProviderInstrumentationTest {
+
+ private val context: Context = ApplicationProvider.getApplicationContext()
+ private val contentResolver: ContentResolver = context.contentResolver
+
+ @Test
+ fun watchNextProgram_supportsInsertUpdateDeleteRoundTrip() {
+ assumeTrue("Launcher provider tests require an Android TV device", isTelevisionDevice())
+
+ val key = "watch-next-${UUID.randomUUID()}"
+ val insertUri = try {
+ contentResolver.insert(
+ TvContract.WatchNextPrograms.CONTENT_URI,
+ buildWatchNextValues(key, title = "Instrumentation Watch Next")
+ )
+ } catch (throwable: Throwable) {
+ throw AssertionError(buildFailureMessage("Watch Next insert failed", throwable))
+ }
+
+ assertNotNull(buildFailureMessage("Watch Next insert returned null", null), insertUri)
+ val rowUri = insertUri!!
+
+ try {
+ val inserted = querySingle(
+ uri = rowUri,
+ projection = arrayOf(COLUMN_TITLE, COLUMN_DESCRIPTION, COLUMN_INTERNAL_PROVIDER_ID),
+ mapper = { cursor ->
+ Triple(
+ cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_TITLE)),
+ cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_DESCRIPTION)),
+ cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_INTERNAL_PROVIDER_ID))
+ )
+ }
+ )
+
+ assertEquals("Instrumentation Watch Next", inserted.first)
+ assertEquals(key, inserted.third)
+
+ val updateCount = contentResolver.update(
+ rowUri,
+ buildWatchNextValues(key, title = "Updated Watch Next"),
+ null,
+ null
+ )
+ assertTrue(buildFailureMessage("Watch Next update affected no rows", null), updateCount > 0)
+
+ val updatedTitle = querySingle(
+ uri = rowUri,
+ projection = arrayOf(COLUMN_TITLE),
+ mapper = { cursor -> cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_TITLE)) }
+ )
+ assertEquals("Updated Watch Next", updatedTitle)
+ } finally {
+ contentResolver.delete(rowUri, null, null)
+ assertRowMissing(rowUri, "Watch Next delete failed")
+ }
+ }
+
+ @Test
+ fun previewChannelAndProgram_supportRoundTrip() {
+ assumeTrue("Launcher provider tests require an Android TV device", isTelevisionDevice())
+
+ val key = "preview-channel-${UUID.randomUUID()}"
+ val channelUri = try {
+ contentResolver.insert(
+ TvContract.Channels.CONTENT_URI,
+ buildPreviewChannelValues(key, "Instrumentation Channel")
+ )
+ } catch (throwable: Throwable) {
+ throw AssertionError(buildFailureMessage("Preview channel insert failed", throwable))
+ }
+
+ assertNotNull(buildFailureMessage("Preview channel insert returned null", null), channelUri)
+ val resolvedChannelUri = channelUri!!
+ val channelId = ContentUris.parseId(resolvedChannelUri)
+ val programKey = "preview-program-${UUID.randomUUID()}"
+
+ try {
+ val programUri = try {
+ contentResolver.insert(
+ TvContract.PreviewPrograms.CONTENT_URI,
+ buildPreviewProgramValues(channelId, programKey, "Instrumentation Program")
+ )
+ } catch (throwable: Throwable) {
+ throw AssertionError(buildFailureMessage("Preview program insert failed", throwable))
+ }
+
+ assertNotNull(buildFailureMessage("Preview program insert returned null", null), programUri)
+ val resolvedProgramUri = programUri!!
+
+ try {
+ val inserted = querySingle(
+ uri = resolvedProgramUri,
+ projection = arrayOf(COLUMN_TITLE, COLUMN_INTERNAL_PROVIDER_ID),
+ mapper = { cursor ->
+ Pair(
+ cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_TITLE)),
+ cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_INTERNAL_PROVIDER_ID))
+ )
+ }
+ )
+ assertEquals("Instrumentation Program", inserted.first)
+ assertEquals(programKey, inserted.second)
+
+ val updatedRows = contentResolver.update(
+ resolvedProgramUri,
+ buildPreviewProgramValues(channelId, programKey, "Updated Program"),
+ null,
+ null
+ )
+ assertTrue(buildFailureMessage("Preview program update affected no rows", null), updatedRows > 0)
+
+ val updatedTitle = querySingle(
+ uri = resolvedProgramUri,
+ projection = arrayOf(COLUMN_TITLE),
+ mapper = { cursor -> cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_TITLE)) }
+ )
+ assertEquals("Updated Program", updatedTitle)
+ } finally {
+ contentResolver.delete(resolvedProgramUri, null, null)
+ assertRowMissing(resolvedProgramUri, "Preview program delete failed")
+ }
+ } finally {
+ contentResolver.delete(resolvedChannelUri, null, null)
+ assertRowMissing(resolvedChannelUri, "Preview channel delete failed")
+ }
+ }
+
+ private fun buildWatchNextValues(key: String, title: String): ContentValues = ContentValues().apply {
+ put(COLUMN_INTERNAL_PROVIDER_ID, key)
+ put(COLUMN_TITLE, title)
+ put(COLUMN_DESCRIPTION, "Instrumentation validation for Watch Next")
+ put(COLUMN_POSTER_ART_URI, resourceArtworkUri().toString())
+ put(COLUMN_INTENT_URI, mainActivityIntentUri())
+ put(COLUMN_LAST_PLAYBACK_POSITION_MILLIS, 30_000L)
+ put(COLUMN_DURATION_MILLIS, 120_000L)
+ put(COLUMN_LAST_ENGAGEMENT_TIME_UTC_MILLIS, System.currentTimeMillis())
+ put(COLUMN_WATCH_NEXT_TYPE, TvContract.WatchNextPrograms.WATCH_NEXT_TYPE_CONTINUE)
+ }
+
+ private fun buildPreviewChannelValues(key: String, title: String): ContentValues = ContentValues().apply {
+ put(COLUMN_TYPE, TvContract.Channels.TYPE_PREVIEW)
+ put(COLUMN_DISPLAY_NAME, title)
+ put(COLUMN_DESCRIPTION, "Instrumentation validation for preview channels")
+ put(COLUMN_INTERNAL_PROVIDER_ID, key)
+ put(COLUMN_APP_LINK_INTENT_URI, mainActivityIntentUri())
+ }
+
+ private fun buildPreviewProgramValues(channelId: Long, key: String, title: String): ContentValues = ContentValues().apply {
+ put(COLUMN_CHANNEL_ID, channelId)
+ put(COLUMN_TYPE, TvContract.PreviewPrograms.TYPE_MOVIE)
+ put(COLUMN_TITLE, title)
+ put(COLUMN_DESCRIPTION, "Instrumentation validation for preview programs")
+ put(COLUMN_POSTER_ART_URI, resourceArtworkUri().toString())
+ put(COLUMN_INTENT_URI, mainActivityIntentUri())
+ put(COLUMN_WEIGHT, 100)
+ put(COLUMN_INTERNAL_PROVIDER_ID, key)
+ put(COLUMN_DURATION_MILLIS, 120_000L)
+ put(COLUMN_LAST_PLAYBACK_POSITION_MILLIS, 15_000L)
+ }
+
+ private fun resourceArtworkUri(): Uri =
+ Uri.parse("android.resource://${context.packageName}/${com.streamvault.app.R.mipmap.ic_launcher_vault}")
+
+ private fun mainActivityIntentUri(): String =
+ Intent(context, com.streamvault.app.MainActivity::class.java)
+ .setAction(Intent.ACTION_VIEW)
+ .toUri(Intent.URI_INTENT_SCHEME)
+
+ private fun isTelevisionDevice(): Boolean =
+ context.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
+
+ private fun assertRowMissing(uri: Uri, prefix: String) {
+ val remaining = contentResolver.query(uri, arrayOf(BaseColumns._ID), null, null, null)
+ ?.use { cursor -> cursor.count }
+ ?: 0
+ assertEquals(buildFailureMessage(prefix, null), 0, remaining)
+ }
+
+ private fun <T> querySingle(uri: Uri, projection: Array<String>, mapper: (android.database.Cursor) -> T): T {
+ return contentResolver.query(uri, projection, null, null, null)?.use { cursor ->
+ assertTrue(buildFailureMessage("Query returned no rows for $uri", null), cursor.moveToFirst())
+ mapper(cursor)
+ } ?: throw AssertionError(buildFailureMessage("Query returned null cursor for $uri", null))
+ }
+
+ private fun buildFailureMessage(message: String, throwable: Throwable?): String {
+ val packageManager = context.packageManager
+ val leanback = packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
+ val launcherPackages = packageManager.queryIntentActivities(
+ Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_HOME),
+ PackageManager.MATCH_DEFAULT_ONLY
+ ).joinToString { it.activityInfo.packageName }
+
+ throwable?.let {
+ Log.e(TAG, message, it)
+ }
+
+ val details = listOf(
+ message,
+ "manufacturer=${Build.MANUFACTURER}",
+ "model=${Build.MODEL}",
+ "sdk=${Build.VERSION.SDK_INT}",
+ "leanback=$leanback",
+ "homePackages=$launcherPackages",
+ "watchNextAuthority=${TvContract.WatchNextPrograms.CONTENT_URI.authority}",
+ "channelsAuthority=${TvContract.Channels.CONTENT_URI.authority}",
+ throwable?.let { "error=${it::class.java.simpleName}:${it.message}" }
+ ).filterNotNull()
+
+ return details.joinToString(separator = " | ")
+ }
+
+ private companion object {
+ const val TAG = "LauncherProviderTest"
+ const val COLUMN_TYPE = "type"
+ const val COLUMN_CHANNEL_ID = "channel_id"
+ const val COLUMN_DISPLAY_NAME = "display_name"
+ const val COLUMN_TITLE = "title"
+ const val COLUMN_DESCRIPTION = "description"
+ const val COLUMN_INTERNAL_PROVIDER_ID = "internal_provider_id"
+ const val COLUMN_APP_LINK_INTENT_URI = "app_link_intent_uri"
+ const val COLUMN_INTENT_URI = "intent_uri"
+ const val COLUMN_POSTER_ART_URI = "poster_art_uri"
+ const val COLUMN_WEIGHT = "weight"
+ const val COLUMN_DURATION_MILLIS = "duration_millis"
+ const val COLUMN_LAST_PLAYBACK_POSITION_MILLIS = "last_playback_position_millis"
+ const val COLUMN_LAST_ENGAGEMENT_TIME_UTC_MILLIS = "last_engagement_time_utc_millis"
+ const val COLUMN_WATCH_NEXT_TYPE = "watch_next_type"
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index d775dd5b..1968a121 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -4,6 +4,8 @@
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+ <uses-permission android:name="com.google.android.tv.permission.WRITE_EPG_DATA" />
+ <uses-permission android:name="android.permission.BIND_TV_INPUT" />
<uses-feature
android:name="android.software.leanback"
@@ -31,6 +33,20 @@
android:supportsPictureInPicture="true"
android:screenOrientation="landscape">
+ <intent-filter>
+ <action android:name="android.intent.action.SEARCH" />
+ <category android:name="android.intent.category.DEFAULT" />
+ </intent-filter>
+
+ <intent-filter>
+ <action android:name="android.intent.action.ASSIST" />
+ <category android:name="android.intent.category.DEFAULT" />
+ </intent-filter>
+
+ <meta-data
+ android:name="android.app.searchable"
+ android:resource="@xml/searchable" />
+
<!-- TV Launcher entry point -->
<intent-filter>
<action android:name="android.intent.action.MAIN" />
@@ -39,6 +55,32 @@
</intent-filter>
</activity>
+ <activity
+ android:name=".cast.CastRouteChooserActivity"
+ android:exported="false"
+ android:excludeFromRecents="true"
+ android:launchMode="singleTop"
+ android:theme="@style/Theme.StreamVault.CastChooser" />
+
+ <service
+ android:name=".tvinput.StreamVaultTvInputService"
+ android:exported="true"
+ android:label="StreamVault Live Channels"
+ android:permission="android.permission.BIND_TV_INPUT">
+
+ <intent-filter>
+ <action android:name="android.media.tv.TvInputService" />
+ </intent-filter>
+
+ <meta-data
+ android:name="android.media.tv.input"
+ android:resource="@xml/tv_input_service" />
+ </service>
+
+ <meta-data
+ android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+ android:value="com.streamvault.app.cast.StreamVaultCastOptionsProvider" />
+
</application>
diff --git a/app/src/main/java/com/streamvault/app/MainActivity.kt b/app/src/main/java/com/streamvault/app/MainActivity.kt
index e0cefe0b..4d6d9bc8 100644
--- a/app/src/main/java/com/streamvault/app/MainActivity.kt
+++ b/app/src/main/java/com/streamvault/app/MainActivity.kt
@@ -1,5 +1,7 @@
package com.streamvault.app
+import android.app.SearchManager
+import android.content.Intent
import android.app.PictureInPictureParams
import android.os.Bundle
import android.os.Build
@@ -7,7 +9,15 @@ import android.os.StrictMode
import android.util.Rational
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
+import androidx.lifecycle.lifecycleScope
+import com.streamvault.app.cast.CastManager
+import com.streamvault.app.cast.CastRouteChooserActivity
import com.streamvault.app.navigation.AppNavigation
+import com.streamvault.app.navigation.ExternalNavigationRequest
+import com.streamvault.app.navigation.PlayerNavigationRequest
+import com.streamvault.app.tv.LauncherRecommendationsManager
+import com.streamvault.app.tv.WatchNextManager
+import com.streamvault.app.tvinput.TvInputChannelSyncManager
import com.streamvault.app.ui.theme.StreamVaultTheme
import dagger.hilt.android.AndroidEntryPoint
@@ -28,13 +38,20 @@ import android.content.Context
import android.content.ContextWrapper
import android.content.res.AssetManager
import android.content.res.Resources
+import android.speech.RecognizerIntent
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
+ companion object {
+ const val EXTRA_PLAYER_REQUEST = "com.streamvault.app.extra.PLAYER_REQUEST"
+ const val EXTRA_EXTERNAL_ROUTE = "com.streamvault.app.extra.EXTERNAL_ROUTE"
+ }
+
private data class PlayerPictureInPictureState(
val enabled: Boolean = false,
val isPlaying: Boolean = false,
@@ -44,9 +61,25 @@ class MainActivity : ComponentActivity() {
@Inject
lateinit var preferencesRepository: PreferencesRepository
+ @Inject
+ lateinit var watchNextManager: WatchNextManager
+
+ @Inject
+ lateinit var launcherRecommendationsManager: LauncherRecommendationsManager
+
+ @Inject
+ lateinit var tvInputChannelSyncManager: TvInputChannelSyncManager
+
+ @Inject
+ lateinit var castManager: CastManager
+
private val _pictureInPictureModeFlow = MutableStateFlow(false)
val pictureInPictureModeFlow: StateFlow<Boolean> = _pictureInPictureModeFlow.asStateFlow()
+ private val _externalNavigationRequestFlow = MutableStateFlow<ExternalNavigationRequest?>(null)
+ val externalNavigationRequestFlow: StateFlow<ExternalNavigationRequest?> =
+ _externalNavigationRequestFlow.asStateFlow()
+
private var playerPictureInPictureState = PlayerPictureInPictureState()
override fun onCreate(savedInstanceState: Bundle?) {
@@ -60,6 +93,13 @@ class MainActivity : ComponentActivity() {
}
super.onCreate(savedInstanceState)
_pictureInPictureModeFlow.value = isInPictureInPictureMode
+ handleExternalIntent(intent)
+ castManager.ensureInitialized()
+ lifecycleScope.launch {
+ watchNextManager.refreshWatchNext()
+ launcherRecommendationsManager.refreshRecommendations()
+ tvInputChannelSyncManager.refreshTvInputCatalog()
+ }
setContent {
val appLanguage by preferencesRepository.appLanguage.collectAsState(initial = "system")
val currentContext = LocalContext.current
@@ -105,12 +145,18 @@ class MainActivity : ComponentActivity() {
LocalLayoutDirection provides layoutDirection
) {
StreamVaultTheme {
- AppNavigation()
+ AppNavigation(mainActivity = this@MainActivity)
}
}
}
}
+ override fun onNewIntent(intent: Intent) {
+ super.onNewIntent(intent)
+ setIntent(intent)
+ handleExternalIntent(intent)
+ }
+
override fun onUserLeaveHint() {
super.onUserLeaveHint()
enterPlayerPictureInPictureModeIfEligible()
@@ -143,16 +189,24 @@ class MainActivity : ComponentActivity() {
applyPlayerPictureInPictureParams()
}
+ fun clearExternalNavigationRequest() {
+ _externalNavigationRequestFlow.value = null
+ }
+
fun enterPlayerPictureInPictureModeFromPlayer(): Boolean {
- return enterPlayerPictureInPictureModeIfEligible()
+ return enterPlayerPictureInPictureModeIfEligible(requirePlaying = false)
+ }
+
+ fun openCastRouteChooser() {
+ startActivity(Intent(this, CastRouteChooserActivity::class.java))
}
- private fun enterPlayerPictureInPictureModeIfEligible(): Boolean {
+ private fun enterPlayerPictureInPictureModeIfEligible(requirePlaying: Boolean = true): Boolean {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O || isInPictureInPictureMode) {
return false
}
val state = playerPictureInPictureState
- if (!state.enabled || !state.isPlaying) {
+ if (!state.enabled || (requirePlaying && !state.isPlaying)) {
return false
}
val params = buildPlayerPictureInPictureParams(state)
@@ -180,4 +234,36 @@ class MainActivity : ComponentActivity() {
if (videoWidth <= 0 || videoHeight <= 0) return null
return Rational(videoWidth, videoHeight)
}
+
+ private fun handleExternalIntent(intent: Intent?) {
+ val request = intent?.toExternalNavigationRequest() ?: return
+ _externalNavigationRequestFlow.value = request
+ }
+
+ private fun Intent.toExternalNavigationRequest(): ExternalNavigationRequest? {
+ readPlayerRequestExtra()?.let { return ExternalNavigationRequest.Player(it) }
+ getStringExtra(EXTRA_EXTERNAL_ROUTE)?.let { return ExternalNavigationRequest.Route(it) }
+
+ val query = when (action) {
+ Intent.ACTION_SEARCH,
+ Intent.ACTION_ASSIST,
+ RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE -> {
+ getStringExtra(SearchManager.QUERY)
+ ?: getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS)?.firstOrNull()
+ }
+
+ else -> null
+ }?.trim().orEmpty()
+
+ return query.takeIf { it.isNotBlank() }?.let(ExternalNavigationRequest::Search)
+ }
+
+ @Suppress("DEPRECATION")
+ private fun Intent.readPlayerRequestExtra(): PlayerNavigationRequest? {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ getSerializableExtra(EXTRA_PLAYER_REQUEST, PlayerNavigationRequest::class.java)
+ } else {
+ getSerializableExtra(EXTRA_PLAYER_REQUEST) as? PlayerNavigationRequest
+ }
+ }
}
diff --git a/app/src/main/java/com/streamvault/app/StreamVaultApp.kt b/app/src/main/java/com/streamvault/app/StreamVaultApp.kt
index bf00f172..ed452786 100644
--- a/app/src/main/java/com/streamvault/app/StreamVaultApp.kt
+++ b/app/src/main/java/com/streamvault/app/StreamVaultApp.kt
@@ -7,6 +7,7 @@ import coil3.SingletonImageLoader
import coil3.disk.DiskCache
import coil3.memory.MemoryCache
import coil3.request.crossfade
+import com.streamvault.app.ui.accessibility.isReducedMotionEnabled
import dagger.hilt.android.HiltAndroidApp
import kotlinx.coroutines.Dispatchers
import okio.Path.Companion.toOkioPath
@@ -58,7 +59,7 @@ class StreamVaultApp : Application(), SingletonImageLoader.Factory {
// Limit concurrent decoding and fetching to 6 for TV hardware constraints
.fetcherCoroutineContext(Dispatchers.IO.limitedParallelism(6))
.decoderCoroutineContext(Dispatchers.Default.limitedParallelism(4))
- .crossfade(true)
+ .crossfade(!isReducedMotionEnabled(context))
.build()
}
}
diff --git a/app/src/main/java/com/streamvault/app/cast/CastManager.kt b/app/src/main/java/com/streamvault/app/cast/CastManager.kt
new file mode 100644
index 00000000..32781ed5
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/cast/CastManager.kt
@@ -0,0 +1,175 @@
+package com.streamvault.app.cast
+
+import android.content.Context
+import android.net.Uri
+import android.util.Log
+import androidx.mediarouter.media.MediaRouteSelector
+import com.google.android.gms.cast.CastMediaControlIntent
+import com.google.android.gms.cast.MediaInfo
+import com.google.android.gms.cast.MediaLoadRequestData
+import com.google.android.gms.cast.MediaMetadata
+import com.google.android.gms.cast.framework.CastContext
+import com.google.android.gms.cast.framework.CastSession
+import com.google.android.gms.cast.framework.SessionManagerListener
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class CastManager @Inject constructor(
+ @ApplicationContext private val context: Context
+) {
+
+ private val _connectionState = MutableStateFlow(CastConnectionState.UNAVAILABLE)
+ val connectionState: StateFlow<CastConnectionState> = _connectionState.asStateFlow()
+
+ private var castContext: CastContext? = null
+ private var initialized = false
+ private var pendingRequest: CastMediaRequest? = null
+
+ private val sessionManagerListener = object : SessionManagerListener<CastSession> {
+ override fun onSessionStarting(session: CastSession) {
+ _connectionState.value = CastConnectionState.CONNECTING
+ }
+
+ override fun onSessionStarted(session: CastSession, sessionId: String) {
+ _connectionState.value = CastConnectionState.CONNECTED
+ loadPendingRequest(session)
+ }
+
+ override fun onSessionStartFailed(session: CastSession, error: Int) {
+ _connectionState.value = CastConnectionState.DISCONNECTED
+ Log.w(TAG, "Cast session failed to start: $error")
+ }
+
+ override fun onSessionEnding(session: CastSession) {
+ _connectionState.value = CastConnectionState.DISCONNECTED
+ }
+
+ override fun onSessionEnded(session: CastSession, error: Int) {
+ _connectionState.value = CastConnectionState.DISCONNECTED
+ }
+
+ override fun onSessionResuming(session: CastSession, sessionId: String) {
+ _connectionState.value = CastConnectionState.CONNECTING
+ }
+
+ override fun onSessionResumed(session: CastSession, wasSuspended: Boolean) {
+ _connectionState.value = CastConnectionState.CONNECTED
+ loadPendingRequest(session)
+ }
+
+ override fun onSessionResumeFailed(session: CastSession, error: Int) {
+ _connectionState.value = CastConnectionState.DISCONNECTED
+ }
+
+ override fun onSessionSuspended(session: CastSession, reason: Int) {
+ _connectionState.value = CastConnectionState.CONNECTING
+ }
+ }
+
+ fun ensureInitialized() {
+ if (initialized) return
+ initialized = true
+ runCatching {
+ CastContext.getSharedInstance(context)
+ }.onSuccess { resolvedContext ->
+ castContext = resolvedContext
+ resolvedContext.sessionManager.addSessionManagerListener(sessionManagerListener, CastSession::class.java)
+ _connectionState.value = currentConnectionState(resolvedContext)
+ }.onFailure { throwable ->
+ _connectionState.value = CastConnectionState.UNAVAILABLE
+ Log.w(TAG, "Google Cast is unavailable on this device", throwable)
+ }
+ }
+
+ fun buildRouteSelector(): MediaRouteSelector = MediaRouteSelector.Builder()
+ .addControlCategory(
+ CastMediaControlIntent.categoryForCast(
+ CastMediaControlIntent.DEFAULT_MEDIA_RECEIVER_APPLICATION_ID
+ )
+ )
+ .build()
+
+ fun startCasting(request: CastMediaRequest): CastStartResult {
+ ensureInitialized()
+ val resolvedContext = castContext ?: return CastStartResult.UNAVAILABLE
+ if (!isRequestSupported(request)) {
+ return CastStartResult.UNSUPPORTED
+ }
+
+ pendingRequest = request
+ val activeSession = resolvedContext.sessionManager.currentCastSession
+ return if (activeSession?.isConnected == true) {
+ loadMedia(activeSession, request)
+ pendingRequest = null
+ CastStartResult.STARTED
+ } else {
+ CastStartResult.ROUTE_SELECTION_REQUIRED
+ }
+ }
+
+ fun stopCasting() {
+ ensureInitialized()
+ pendingRequest = null
+ castContext?.sessionManager?.endCurrentSession(true)
+ _connectionState.value = CastConnectionState.DISCONNECTED
+ }
+
+ private fun loadPendingRequest(session: CastSession) {
+ val request = pendingRequest ?: return
+ loadMedia(session, request)
+ pendingRequest = null
+ }
+
+ private fun loadMedia(session: CastSession, request: CastMediaRequest) {
+ val remoteMediaClient = session.remoteMediaClient ?: return
+ val metadataType = if (request.isLive) MediaMetadata.MEDIA_TYPE_TV_SHOW else MediaMetadata.MEDIA_TYPE_MOVIE
+ val metadata = MediaMetadata(metadataType).apply {
+ putString(MediaMetadata.KEY_TITLE, request.title)
+ request.subtitle?.takeIf { it.isNotBlank() }?.let {
+ putString(MediaMetadata.KEY_SUBTITLE, it)
+ }
+ request.artworkUrl?.takeIf { it.isNotBlank() }?.let {
+ addImage(com.google.android.gms.common.images.WebImage(Uri.parse(it)))
+ }
+ }
+
+ val mediaInfo = MediaInfo.Builder(request.url)
+ .setContentType(request.mimeType ?: DEFAULT_CONTENT_TYPE)
+ .setStreamType(if (request.isLive) MediaInfo.STREAM_TYPE_LIVE else MediaInfo.STREAM_TYPE_BUFFERED)
+ .setMetadata(metadata)
+ .build()
+
+ remoteMediaClient.load(
+ MediaLoadRequestData.Builder()
+ .setMediaInfo(mediaInfo)
+ .setAutoplay(true)
+ .setCurrentTime(request.startPositionMs)
+ .build()
+ )
+ }
+
+ private fun currentConnectionState(castContext: CastContext): CastConnectionState {
+ val activeSession = castContext.sessionManager.currentCastSession
+ return when {
+ activeSession?.isConnected == true -> CastConnectionState.CONNECTED
+ activeSession != null -> CastConnectionState.CONNECTING
+ else -> CastConnectionState.DISCONNECTED
+ }
+ }
+
+ private fun isRequestSupported(request: CastMediaRequest): Boolean {
+ val mimeType = request.mimeType.orEmpty().lowercase()
+ if (request.url.startsWith("rtsp", ignoreCase = true)) return false
+ return mimeType.isBlank() || mimeType != "application/x-rtsp"
+ }
+
+ private companion object {
+ const val TAG = "CastManager"
+ const val DEFAULT_CONTENT_TYPE = "application/x-mpegURL"
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/cast/CastModels.kt b/app/src/main/java/com/streamvault/app/cast/CastModels.kt
new file mode 100644
index 00000000..1fde2de6
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/cast/CastModels.kt
@@ -0,0 +1,25 @@
+package com.streamvault.app.cast
+
+data class CastMediaRequest(
+ val url: String,
+ val title: String,
+ val subtitle: String? = null,
+ val artworkUrl: String? = null,
+ val mimeType: String? = null,
+ val isLive: Boolean = false,
+ val startPositionMs: Long = 0L
+)
+
+enum class CastConnectionState {
+ UNAVAILABLE,
+ DISCONNECTED,
+ CONNECTING,
+ CONNECTED
+}
+
+enum class CastStartResult {
+ STARTED,
+ ROUTE_SELECTION_REQUIRED,
+ UNAVAILABLE,
+ UNSUPPORTED
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/cast/CastRouteChooserActivity.kt b/app/src/main/java/com/streamvault/app/cast/CastRouteChooserActivity.kt
new file mode 100644
index 00000000..38ef2532
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/cast/CastRouteChooserActivity.kt
@@ -0,0 +1,33 @@
+package com.streamvault.app.cast
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.mediarouter.app.MediaRouteChooserDialog
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class CastRouteChooserActivity : AppCompatActivity() {
+
+ @Inject
+ lateinit var castManager: CastManager
+
+ private var chooserDialog: MediaRouteChooserDialog? = null
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ castManager.ensureInitialized()
+
+ chooserDialog = MediaRouteChooserDialog(this).apply {
+ setRouteSelector(castManager.buildRouteSelector())
+ setOnDismissListener { finish() }
+ show()
+ }
+ }
+
+ override fun onStop() {
+ chooserDialog?.dismiss()
+ chooserDialog = null
+ super.onStop()
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/cast/StreamVaultCastOptionsProvider.kt b/app/src/main/java/com/streamvault/app/cast/StreamVaultCastOptionsProvider.kt
new file mode 100644
index 00000000..7cf88442
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/cast/StreamVaultCastOptionsProvider.kt
@@ -0,0 +1,29 @@
+package com.streamvault.app.cast
+
+import android.content.Context
+import com.google.android.gms.cast.CastMediaControlIntent
+import com.google.android.gms.cast.LaunchOptions
+import com.google.android.gms.cast.framework.CastOptions
+import com.google.android.gms.cast.framework.OptionsProvider
+import com.google.android.gms.cast.framework.SessionProvider
+import com.google.android.gms.cast.framework.media.CastMediaOptions
+import com.google.android.gms.cast.framework.media.NotificationOptions
+import com.google.android.gms.cast.framework.media.widget.ExpandedControllerActivity
+
+class StreamVaultCastOptionsProvider : OptionsProvider {
+ override fun getCastOptions(context: Context): CastOptions {
+ val notificationOptions = NotificationOptions.Builder().build()
+ val mediaOptions = CastMediaOptions.Builder()
+ .setNotificationOptions(notificationOptions)
+ .setExpandedControllerActivityClassName(ExpandedControllerActivity::class.java.name)
+ .build()
+
+ return CastOptions.Builder()
+ .setReceiverApplicationId(CastMediaControlIntent.DEFAULT_MEDIA_RECEIVER_APPLICATION_ID)
+ .setLaunchOptions(LaunchOptions.Builder().setRelaunchIfRunning(false).build())
+ .setCastMediaOptions(mediaOptions)
+ .build()
+ }
+
+ override fun getAdditionalSessionProviders(context: Context): List<SessionProvider> = emptyList()
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt b/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt
index 7bd8a6c7..4a891eff 100644
--- a/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt
+++ b/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt
@@ -37,7 +37,8 @@ object DatabaseModule {
StreamVaultDatabase.MIGRATION_9_10,
StreamVaultDatabase.MIGRATION_10_11,
StreamVaultDatabase.MIGRATION_11_12,
- StreamVaultDatabase.MIGRATION_12_13
+ StreamVaultDatabase.MIGRATION_12_13,
+ StreamVaultDatabase.MIGRATION_13_14
)
// NOTE: fallbackToDestructiveMigration() intentionally removed.
// All future schema changes MUST add a corresponding Migration in StreamVaultDatabase.
diff --git a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
index 0f758f61..e14ead77 100644
--- a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
+++ b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
@@ -2,7 +2,9 @@ package com.streamvault.app.di
import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.data.local.RoomDatabaseTransactionRunner
+import com.streamvault.data.preferences.PreferencesRepository
import com.streamvault.data.repository.*
+import com.streamvault.domain.manager.ParentalControlSessionStore
import com.streamvault.domain.repository.*
import dagger.Binds
import dagger.Module
@@ -51,6 +53,9 @@ abstract class RepositoryModule {
@Binds @Singleton
abstract fun bindRecordingManager(impl: com.streamvault.data.manager.RecordingManagerImpl): com.streamvault.domain.manager.RecordingManager
+ @Binds @Singleton
+ abstract fun bindParentalControlSessionStore(impl: PreferencesRepository): ParentalControlSessionStore
+
companion object {
@Provides
@Singleton
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
index 27ee5536..338ed156 100644
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
@@ -1,7 +1,10 @@
package com.streamvault.app.navigation
+import android.net.Uri
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.compose.dropUnlessResumed
import androidx.navigation.NavHostController
import androidx.navigation.NavOptionsBuilder
@@ -25,6 +28,7 @@ import com.streamvault.app.ui.screens.provider.ProviderSetupScreen
import com.streamvault.app.ui.screens.series.SeriesScreen
import com.streamvault.app.ui.screens.settings.SettingsScreen
import com.streamvault.app.ui.screens.welcome.WelcomeScreen
+import com.streamvault.app.MainActivity
import java.io.Serializable
@@ -39,6 +43,7 @@ data class PlayerNavigationRequest(
val providerId: Long? = null,
val isVirtual: Boolean = false,
val contentType: String = "LIVE",
+ val artworkUrl: String? = null,
val archiveStartMs: Long? = null,
val archiveEndMs: Long? = null,
val archiveTitle: String? = null,
@@ -58,6 +63,7 @@ object Routes {
const val SETTINGS = "settings"
const val PLAYER = "player"
const val SEARCH = "search"
+ const val SEARCH_DESTINATION = "search?query={query}"
const val SERIES_DETAIL = "series_detail/{seriesId}"
const val WELCOME = "welcome"
const val PARENTAL_CONTROL_GROUPS = "parental_control_groups/{providerId}"
@@ -101,7 +107,8 @@ object Routes {
internalId = movie.id,
categoryId = movie.categoryId,
providerId = movie.providerId,
- contentType = "MOVIE"
+ contentType = "MOVIE",
+ artworkUrl = movie.posterUrl ?: movie.backdropUrl
)
}
@@ -111,10 +118,14 @@ object Routes {
title = "${episode.title} - S${episode.seasonNumber}E${episode.episodeNumber}",
internalId = episode.id,
providerId = episode.providerId,
- contentType = "SERIES_EPISODE"
+ contentType = "SERIES_EPISODE",
+ artworkUrl = episode.coverUrl
)
}
+ fun search(query: String? = null): String =
+ if (query.isNullOrBlank()) SEARCH else "$SEARCH?query=${Uri.encode(query)}"
+
fun player(
streamUrl: String,
title: String,
@@ -124,6 +135,7 @@ object Routes {
providerId: Long? = null,
isVirtual: Boolean = false,
contentType: String = "LIVE",
+ artworkUrl: String? = null,
archiveStartMs: Long? = null,
archiveEndMs: Long? = null,
archiveTitle: String? = null,
@@ -138,6 +150,7 @@ object Routes {
providerId = providerId,
isVirtual = isVirtual,
contentType = contentType,
+ artworkUrl = artworkUrl,
archiveStartMs = archiveStartMs,
archiveEndMs = archiveEndMs,
archiveTitle = archiveTitle,
@@ -169,8 +182,30 @@ private fun NavHostController.navigateToPlayer(request: PlayerNavigationRequest)
}
@Composable
-fun AppNavigation() {
+fun AppNavigation(mainActivity: MainActivity) {
val navController = rememberNavController()
+ val externalNavigationRequest = mainActivity.externalNavigationRequestFlow.collectAsStateWithLifecycle().value
+
+ LaunchedEffect(externalNavigationRequest) {
+ when (val request = externalNavigationRequest) {
+ is ExternalNavigationRequest.Player -> {
+ navController.navigateToPlayer(request.request)
+ mainActivity.clearExternalNavigationRequest()
+ }
+
+ is ExternalNavigationRequest.Route -> {
+ navController.navigate(request.route) { launchSingleTop = true }
+ mainActivity.clearExternalNavigationRequest()
+ }
+
+ is ExternalNavigationRequest.Search -> {
+ navController.navigate(Routes.search(request.query)) { launchSingleTop = true }
+ mainActivity.clearExternalNavigationRequest()
+ }
+
+ null -> Unit
+ }
+ }
// NAV-M02/NAV-H02: Single helper replacing repeated tab lambdas without serializing
// each tab's full UI tree into saved state on every switch.
@@ -493,8 +528,14 @@ fun AppNavigation() {
)
}
- composable(Routes.SEARCH) {
+ composable(
+ route = Routes.SEARCH_DESTINATION,
+ arguments = listOf(
+ navArgument("query") { type = NavType.StringType; defaultValue = "" }
+ )
+ ) { backStackEntry ->
com.streamvault.app.ui.screens.search.SearchScreen(
+ initialQuery = backStackEntry.arguments?.getString("query").orEmpty(),
onChannelClick = { channel ->
navController.navigateToPlayer(
Routes.livePlayer(
@@ -531,12 +572,20 @@ fun AppNavigation() {
providerId = playerRequest?.providerId,
isVirtual = playerRequest?.isVirtual ?: false,
contentType = playerRequest?.contentType ?: "LIVE",
+ artworkUrl = playerRequest?.artworkUrl,
archiveStartMs = playerRequest?.archiveStartMs,
archiveEndMs = playerRequest?.archiveEndMs,
archiveTitle = playerRequest?.archiveTitle,
returnRoute = playerRequest?.returnRoute,
onBack = { navController.popBackStack() },
- onNavigate = { route -> navController.navigateIfResumed(route) { launchSingleTop = true } }
+ onNavigate = { route ->
+ navController.navigateIfResumed(route) {
+ launchSingleTop = true
+ if (route == Routes.MULTI_VIEW) {
+ popUpTo(Routes.PLAYER) { inclusive = true }
+ }
+ }
+ }
)
}
diff --git a/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequest.kt b/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequest.kt
new file mode 100644
index 00000000..6a3ee579
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequest.kt
@@ -0,0 +1,7 @@
+package com.streamvault.app.navigation
+
+sealed interface ExternalNavigationRequest {
+ data class Search(val query: String) : ExternalNavigationRequest
+ data class Player(val request: PlayerNavigationRequest) : ExternalNavigationRequest
+ data class Route(val route: String) : ExternalNavigationRequest
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt b/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
new file mode 100644
index 00000000..b8bf0ccf
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
@@ -0,0 +1,396 @@
+package com.streamvault.app.tv
+
+import android.content.ContentUris
+import android.content.ContentValues
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.tv.TvContract
+import android.net.Uri
+import android.provider.BaseColumns
+import android.util.Log
+import com.streamvault.app.MainActivity
+import com.streamvault.app.R
+import com.streamvault.app.navigation.PlayerNavigationRequest
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.Provider
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.PlaybackHistoryRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.domain.repository.SeriesRepository
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.first
+import java.io.OutputStream
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class LauncherRecommendationsManager @Inject constructor(
+ @ApplicationContext private val context: Context,
+ private val providerRepository: ProviderRepository,
+ private val playbackHistoryRepository: PlaybackHistoryRepository,
+ private val movieRepository: MovieRepository,
+ private val seriesRepository: SeriesRepository
+) {
+
+ suspend fun refreshRecommendations() {
+ val provider = providerRepository.getActiveProvider().first()
+ if (provider == null) {
+ deleteAllManagedChannels()
+ return
+ }
+
+ runCatching {
+ val specs = buildChannelSpecs(provider)
+ val existingChannels = loadExistingChannels()
+ val activeKeys = specs.mapTo(mutableSetOf()) { it.key }
+
+ existingChannels
+ .filterKeys { it !in activeKeys }
+ .values
+ .forEach(::deleteChannel)
+
+ specs.forEach { spec ->
+ if (spec.programs.isEmpty()) {
+ existingChannels[spec.key]?.let(::deleteChannel)
+ return@forEach
+ }
+
+ val channelId = existingChannels[spec.key] ?: insertChannel(spec) ?: return@forEach
+ updateChannel(channelId, spec)
+ syncPrograms(channelId, spec)
+ requestChannelBrowsable(channelId)
+ }
+ }.onFailure { throwable ->
+ Log.w(TAG, "Launcher recommendation sync failed", throwable)
+ }
+ }
+
+ private suspend fun buildChannelSpecs(provider: Provider): List<RecommendationChannelSpec> {
+ val continueWatching = playbackHistoryRepository.getRecentlyWatchedByProvider(provider.id, limit = 12)
+ .first()
+ .asSequence()
+ .filter { it.contentType == ContentType.MOVIE || it.contentType == ContentType.SERIES_EPISODE }
+ .filter { it.resumePositionMs > 0L && it.totalDurationMs > 0L }
+ .distinctBy { it.contentType to it.contentId }
+ .sortedByDescending { it.lastWatchedAt }
+ .map { history ->
+ RecommendationProgramSpec(
+ key = "cw:${history.contentType.name}:${history.contentId}",
+ title = history.title,
+ description = context.getString(R.string.saved_preset_watch_next),
+ posterArtUri = artworkUri(history.posterUrl),
+ intentUri = buildPlayerIntent(history.toPlayerRequest()).toUri(Intent.URI_INTENT_SCHEME),
+ weight = history.lastWatchedAt.toInt().coerceAtLeast(0),
+ durationMillis = history.totalDurationMs,
+ playbackPositionMillis = history.resumePositionMs,
+ contentType = history.contentType
+ )
+ }
+ .toList()
+
+ val topMovies = movieRepository.getTopRatedPreview(provider.id, limit = 12)
+ .first()
+ .mapIndexed { index, movie ->
+ RecommendationProgramSpec(
+ key = "movie:${movie.id}",
+ title = movie.name,
+ description = movie.plot ?: movie.genre ?: provider.name,
+ posterArtUri = artworkUri(movie.posterUrl ?: movie.backdropUrl),
+ intentUri = buildPlayerIntent(
+ PlayerNavigationRequest(
+ streamUrl = movie.streamUrl,
+ title = movie.name,
+ internalId = movie.id,
+ categoryId = movie.categoryId,
+ providerId = movie.providerId,
+ contentType = ContentType.MOVIE.name,
+ artworkUrl = movie.posterUrl ?: movie.backdropUrl
+ )
+ ).toUri(Intent.URI_INTENT_SCHEME),
+ weight = (TOP_MOVIE_WEIGHT_BASE - index).coerceAtLeast(0),
+ durationMillis = movie.durationSeconds.toLong() * 1000L,
+ playbackPositionMillis = movie.watchProgress,
+ contentType = ContentType.MOVIE
+ )
+ }
+
+ val freshSeries = seriesRepository.getFreshPreview(provider.id, limit = 12)
+ .first()
+ .mapIndexed { index, series ->
+ RecommendationProgramSpec(
+ key = "series:${series.id}",
+ title = series.name,
+ description = series.plot ?: series.genre ?: provider.name,
+ posterArtUri = artworkUri(series.posterUrl ?: series.backdropUrl),
+ intentUri = buildRouteIntent("series_detail/${series.id}").toUri(Intent.URI_INTENT_SCHEME),
+ weight = (FRESH_SERIES_WEIGHT_BASE - index).coerceAtLeast(0),
+ durationMillis = 0L,
+ playbackPositionMillis = 0L,
+ contentType = ContentType.SERIES
+ )
+ }
+
+ return listOf(
+ RecommendationChannelSpec(
+ key = CHANNEL_CONTINUE_WATCHING,
+ title = context.getString(R.string.tv_channel_continue_watching_title),
+ description = context.getString(R.string.tv_channel_continue_watching_description),
+ programs = continueWatching
+ ),
+ RecommendationChannelSpec(
+ key = CHANNEL_TOP_MOVIES,
+ title = context.getString(R.string.tv_channel_top_movies_title),
+ description = context.getString(R.string.tv_channel_top_movies_description, provider.name),
+ programs = topMovies
+ ),
+ RecommendationChannelSpec(
+ key = CHANNEL_FRESH_SERIES,
+ title = context.getString(R.string.tv_channel_fresh_series_title),
+ description = context.getString(R.string.tv_channel_fresh_series_description, provider.name),
+ programs = freshSeries
+ )
+ )
+ }
+
+ private fun loadExistingChannels(): Map<String, Long> {
+ val projection = arrayOf(
+ BaseColumns._ID,
+ CHANNEL_COLUMN_TYPE,
+ CHANNEL_COLUMN_INTERNAL_PROVIDER_ID
+ )
+ return context.contentResolver.query(
+ TvContract.Channels.CONTENT_URI,
+ projection,
+ null,
+ null,
+ null
+ )?.use { cursor ->
+ val idIndex = cursor.getColumnIndexOrThrow(BaseColumns._ID)
+ val typeIndex = cursor.getColumnIndexOrThrow(CHANNEL_COLUMN_TYPE)
+ val keyIndex = cursor.getColumnIndexOrThrow(CHANNEL_COLUMN_INTERNAL_PROVIDER_ID)
+ buildMap {
+ while (cursor.moveToNext()) {
+ val type = cursor.getString(typeIndex)
+ val key = cursor.getString(keyIndex)
+ if (type == TvContract.Channels.TYPE_PREVIEW && key in MANAGED_CHANNEL_KEYS) {
+ put(key, cursor.getLong(idIndex))
+ }
+ }
+ }
+ }.orEmpty()
+ }
+
+ private fun insertChannel(spec: RecommendationChannelSpec): Long? {
+ val uri = context.contentResolver.insert(TvContract.Channels.CONTENT_URI, buildChannelValues(spec)) ?: return null
+ val channelId = ContentUris.parseId(uri)
+ updateChannelLogo(channelId)
+ return channelId
+ }
+
+ private fun updateChannel(channelId: Long, spec: RecommendationChannelSpec) {
+ context.contentResolver.update(
+ ContentUris.withAppendedId(TvContract.Channels.CONTENT_URI, channelId),
+ buildChannelValues(spec),
+ null,
+ null
+ )
+ }
+
+ private fun syncPrograms(channelId: Long, spec: RecommendationChannelSpec) {
+ val existingPrograms = loadExistingPrograms(channelId)
+ val activeKeys = spec.programs.mapTo(mutableSetOf()) { it.key }
+
+ existingPrograms
+ .filterKeys { it !in activeKeys }
+ .values
+ .forEach { programId ->
+ context.contentResolver.delete(
+ ContentUris.withAppendedId(TvContract.PreviewPrograms.CONTENT_URI, programId),
+ null,
+ null
+ )
+ }
+
+ spec.programs.forEach { program ->
+ val values = buildProgramValues(channelId, program)
+ val existingId = existingPrograms[program.key]
+ if (existingId == null) {
+ context.contentResolver.insert(TvContract.PreviewPrograms.CONTENT_URI, values)
+ } else {
+ context.contentResolver.update(
+ ContentUris.withAppendedId(TvContract.PreviewPrograms.CONTENT_URI, existingId),
+ values,
+ null,
+ null
+ )
+ }
+ }
+ }
+
+ private fun loadExistingPrograms(channelId: Long): Map<String, Long> {
+ val projection = arrayOf(BaseColumns._ID, PREVIEW_COLUMN_INTERNAL_PROVIDER_ID)
+ return context.contentResolver.query(
+ TvContract.buildPreviewProgramsUriForChannel(channelId),
+ projection,
+ null,
+ null,
+ null
+ )?.use { cursor ->
+ val idIndex = cursor.getColumnIndexOrThrow(BaseColumns._ID)
+ val keyIndex = cursor.getColumnIndexOrThrow(PREVIEW_COLUMN_INTERNAL_PROVIDER_ID)
+ buildMap {
+ while (cursor.moveToNext()) {
+ put(cursor.getString(keyIndex), cursor.getLong(idIndex))
+ }
+ }
+ }.orEmpty()
+ }
+
+ private fun buildChannelValues(spec: RecommendationChannelSpec): ContentValues = ContentValues().apply {
+ put(CHANNEL_COLUMN_TYPE, TvContract.Channels.TYPE_PREVIEW)
+ put(CHANNEL_COLUMN_DISPLAY_NAME, spec.title)
+ put(CHANNEL_COLUMN_DESCRIPTION, spec.description)
+ put(CHANNEL_COLUMN_INTERNAL_PROVIDER_ID, spec.key)
+ put(CHANNEL_COLUMN_APP_LINK_INTENT_URI, buildBrowseIntent().toUri(Intent.URI_INTENT_SCHEME))
+ }
+
+ private fun buildProgramValues(channelId: Long, spec: RecommendationProgramSpec): ContentValues = ContentValues().apply {
+ put(PREVIEW_COLUMN_CHANNEL_ID, channelId)
+ put(PREVIEW_COLUMN_TYPE, previewProgramType(spec.contentType))
+ put(PREVIEW_COLUMN_TITLE, spec.title)
+ put(PREVIEW_COLUMN_DESCRIPTION, spec.description)
+ put(PREVIEW_COLUMN_POSTER_ART_URI, spec.posterArtUri.toString())
+ put(PREVIEW_COLUMN_INTENT_URI, spec.intentUri)
+ put(PREVIEW_COLUMN_WEIGHT, spec.weight)
+ put(PREVIEW_COLUMN_INTERNAL_PROVIDER_ID, spec.key)
+ put(PREVIEW_COLUMN_LAST_PLAYBACK_POSITION_MILLIS, spec.playbackPositionMillis)
+ put(PREVIEW_COLUMN_DURATION_MILLIS, spec.durationMillis)
+ }
+
+ private fun previewProgramType(contentType: ContentType): Int = when (contentType) {
+ ContentType.MOVIE -> TvContract.PreviewPrograms.TYPE_MOVIE
+ ContentType.SERIES,
+ ContentType.SERIES_EPISODE -> TvContract.PreviewPrograms.TYPE_TV_EPISODE
+ ContentType.LIVE -> TvContract.PreviewPrograms.TYPE_CLIP
+ }
+
+ private fun buildPlayerIntent(request: PlayerNavigationRequest): Intent =
+ Intent(context, MainActivity::class.java)
+ .setAction(Intent.ACTION_VIEW)
+ .putExtra(MainActivity.EXTRA_PLAYER_REQUEST, request)
+ .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+ private fun buildRouteIntent(route: String): Intent =
+ Intent(context, MainActivity::class.java)
+ .setAction(Intent.ACTION_VIEW)
+ .putExtra(MainActivity.EXTRA_EXTERNAL_ROUTE, route)
+ .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+ private fun buildBrowseIntent(): Intent =
+ Intent(context, MainActivity::class.java)
+ .setAction(Intent.ACTION_VIEW)
+ .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+ private fun requestChannelBrowsable(channelId: Long) {
+ runCatching {
+ TvContract.requestChannelBrowsable(context, channelId)
+ }.onFailure { throwable ->
+ Log.w(TAG, "Unable to request browsable state for channel $channelId", throwable)
+ }
+ }
+
+ private fun updateChannelLogo(channelId: Long) {
+ runCatching {
+ context.contentResolver.openOutputStream(TvContract.buildChannelLogoUri(channelId), "w")
+ ?.use(::writeDefaultLogo)
+ }.onFailure { throwable ->
+ Log.w(TAG, "Unable to write channel logo for $channelId", throwable)
+ }
+ }
+
+ private fun writeDefaultLogo(stream: OutputStream) {
+ val bitmap = BitmapFactory.decodeResource(context.resources, R.mipmap.ic_launcher_vault)
+ bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+ }
+
+ private fun deleteAllManagedChannels() {
+ loadExistingChannels().values.forEach(::deleteChannel)
+ }
+
+ private fun deleteChannel(channelId: Long) {
+ context.contentResolver.delete(
+ ContentUris.withAppendedId(TvContract.Channels.CONTENT_URI, channelId),
+ null,
+ null
+ )
+ }
+
+ private fun artworkUri(url: String?): Uri {
+ val remoteArtwork = url?.takeIf { it.isNotBlank() }
+ if (remoteArtwork != null) {
+ return Uri.parse(remoteArtwork)
+ }
+ return Uri.parse("android.resource://${context.packageName}/${R.mipmap.ic_launcher_vault}")
+ }
+
+ private fun PlaybackHistory.toPlayerRequest(): PlayerNavigationRequest =
+ PlayerNavigationRequest(
+ streamUrl = streamUrl,
+ title = title,
+ internalId = contentId,
+ providerId = providerId,
+ contentType = contentType.name,
+ artworkUrl = posterUrl
+ )
+
+ private data class RecommendationChannelSpec(
+ val key: String,
+ val title: String,
+ val description: String,
+ val programs: List<RecommendationProgramSpec>
+ )
+
+ private data class RecommendationProgramSpec(
+ val key: String,
+ val title: String,
+ val description: String,
+ val posterArtUri: Uri,
+ val intentUri: String,
+ val weight: Int,
+ val durationMillis: Long,
+ val playbackPositionMillis: Long,
+ val contentType: ContentType
+ )
+
+ private companion object {
+ const val TAG = "LauncherRecommendations"
+ const val CHANNEL_CONTINUE_WATCHING = "streamvault_continue_watching"
+ const val CHANNEL_TOP_MOVIES = "streamvault_top_movies"
+ const val CHANNEL_FRESH_SERIES = "streamvault_fresh_series"
+ val MANAGED_CHANNEL_KEYS = setOf(
+ CHANNEL_CONTINUE_WATCHING,
+ CHANNEL_TOP_MOVIES,
+ CHANNEL_FRESH_SERIES
+ )
+ const val TOP_MOVIE_WEIGHT_BASE = 10_000
+ const val FRESH_SERIES_WEIGHT_BASE = 9_000
+ const val CHANNEL_COLUMN_TYPE = "type"
+ const val CHANNEL_COLUMN_DISPLAY_NAME = "display_name"
+ const val CHANNEL_COLUMN_DESCRIPTION = "description"
+ const val CHANNEL_COLUMN_INTERNAL_PROVIDER_ID = "internal_provider_id"
+ const val CHANNEL_COLUMN_APP_LINK_INTENT_URI = "app_link_intent_uri"
+ const val PREVIEW_COLUMN_CHANNEL_ID = "channel_id"
+ const val PREVIEW_COLUMN_TYPE = "type"
+ const val PREVIEW_COLUMN_TITLE = "title"
+ const val PREVIEW_COLUMN_DESCRIPTION = "description"
+ const val PREVIEW_COLUMN_POSTER_ART_URI = "poster_art_uri"
+ const val PREVIEW_COLUMN_INTENT_URI = "intent_uri"
+ const val PREVIEW_COLUMN_WEIGHT = "weight"
+ const val PREVIEW_COLUMN_INTERNAL_PROVIDER_ID = "internal_provider_id"
+ const val PREVIEW_COLUMN_LAST_PLAYBACK_POSITION_MILLIS = "last_playback_position_millis"
+ const val PREVIEW_COLUMN_DURATION_MILLIS = "duration_millis"
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/tv/WatchNextManager.kt b/app/src/main/java/com/streamvault/app/tv/WatchNextManager.kt
new file mode 100644
index 00000000..68ab5be4
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/tv/WatchNextManager.kt
@@ -0,0 +1,154 @@
+package com.streamvault.app.tv
+
+import android.content.ContentUris
+import android.content.ContentValues
+import android.content.Context
+import android.content.Intent
+import android.media.tv.TvContract
+import android.net.Uri
+import android.provider.BaseColumns
+import android.util.Log
+import com.streamvault.app.MainActivity
+import com.streamvault.app.R
+import com.streamvault.app.navigation.PlayerNavigationRequest
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.repository.PlaybackHistoryRepository
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.first
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class WatchNextManager @Inject constructor(
+ @ApplicationContext private val context: Context,
+ private val playbackHistoryRepository: PlaybackHistoryRepository
+) {
+
+ suspend fun refreshWatchNext() {
+ val historyEntries = playbackHistoryRepository.getRecentlyWatched(limit = 40)
+ .first()
+ .asSequence()
+ .filter(::isEligibleForWatchNext)
+ .distinctBy(::watchNextKey)
+ .sortedByDescending { it.lastWatchedAt }
+ .take(MAX_WATCH_NEXT_ITEMS)
+ .toList()
+
+ runCatching {
+ val existingEntries = loadExistingEntries()
+ val targetKeys = historyEntries.mapTo(mutableSetOf(), ::watchNextKey)
+
+ existingEntries
+ .filterKeys { it !in targetKeys }
+ .values
+ .forEach { rowId ->
+ context.contentResolver.delete(
+ ContentUris.withAppendedId(TvContract.WatchNextPrograms.CONTENT_URI, rowId),
+ null,
+ null
+ )
+ }
+
+ historyEntries.forEach { history ->
+ val values = buildWatchNextValues(history)
+ val existingId = existingEntries[watchNextKey(history)]
+ if (existingId == null) {
+ context.contentResolver.insert(TvContract.WatchNextPrograms.CONTENT_URI, values)
+ } else {
+ context.contentResolver.update(
+ ContentUris.withAppendedId(TvContract.WatchNextPrograms.CONTENT_URI, existingId),
+ values,
+ null,
+ null
+ )
+ }
+ }
+ }.onFailure { throwable ->
+ Log.w(TAG, "Watch Next sync failed", throwable)
+ }
+ }
+
+ private fun loadExistingEntries(): Map<String, Long> {
+ val projection = arrayOf(BaseColumns._ID, COLUMN_INTERNAL_PROVIDER_ID)
+ return context.contentResolver.query(
+ TvContract.WatchNextPrograms.CONTENT_URI,
+ projection,
+ null,
+ null,
+ null
+ )?.use { cursor ->
+ val idIndex = cursor.getColumnIndexOrThrow(BaseColumns._ID)
+ val keyIndex = cursor.getColumnIndexOrThrow(COLUMN_INTERNAL_PROVIDER_ID)
+ buildMap {
+ while (cursor.moveToNext()) {
+ put(cursor.getString(keyIndex), cursor.getLong(idIndex))
+ }
+ }
+ }.orEmpty()
+ }
+
+ private fun buildWatchNextValues(history: PlaybackHistory): ContentValues {
+ val launchIntent = Intent(context, MainActivity::class.java)
+ .setAction(Intent.ACTION_VIEW)
+ .putExtra(MainActivity.EXTRA_PLAYER_REQUEST, history.toPlayerRequest())
+ .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+ return ContentValues().apply {
+ put(COLUMN_INTERNAL_PROVIDER_ID, watchNextKey(history))
+ put(COLUMN_TITLE, history.title)
+ put(COLUMN_DESCRIPTION, context.getString(R.string.saved_preset_watch_next))
+ put(COLUMN_POSTER_ART_URI, artworkUriFor(history).toString())
+ put(COLUMN_INTENT_URI, launchIntent.toUri(Intent.URI_INTENT_SCHEME))
+ put(COLUMN_LAST_PLAYBACK_POSITION_MILLIS, history.resumePositionMs)
+ put(COLUMN_DURATION_MILLIS, history.totalDurationMs)
+ put(COLUMN_LAST_ENGAGEMENT_TIME_UTC_MILLIS, history.lastWatchedAt)
+ put(COLUMN_WATCH_NEXT_TYPE, TvContract.WatchNextPrograms.WATCH_NEXT_TYPE_CONTINUE)
+ }
+ }
+
+ private fun artworkUriFor(history: PlaybackHistory): Uri {
+ val remoteArtwork = history.posterUrl?.takeIf { it.isNotBlank() }
+ if (remoteArtwork != null) {
+ return Uri.parse(remoteArtwork)
+ }
+ return Uri.parse("android.resource://${context.packageName}/${R.mipmap.ic_launcher_vault}")
+ }
+
+ private fun isEligibleForWatchNext(history: PlaybackHistory): Boolean {
+ if (history.providerId <= 0L) return false
+ if (history.resumePositionMs <= 0L || history.totalDurationMs <= 0L) return false
+ if (history.contentType != ContentType.MOVIE && history.contentType != ContentType.SERIES_EPISODE) {
+ return false
+ }
+ return history.resumePositionMs < history.totalDurationMs * WATCH_NEXT_COMPLETION_THRESHOLD
+ }
+
+ private fun watchNextKey(history: PlaybackHistory): String =
+ "${history.providerId}:${history.contentType.name}:${history.contentId}"
+
+ private fun PlaybackHistory.toPlayerRequest(): PlayerNavigationRequest =
+ PlayerNavigationRequest(
+ streamUrl = streamUrl,
+ title = title,
+ internalId = contentId,
+ providerId = providerId,
+ contentType = contentType.name,
+ artworkUrl = posterUrl
+ )
+
+ private companion object {
+ const val TAG = "WatchNextManager"
+ const val MAX_WATCH_NEXT_ITEMS = 12
+ const val WATCH_NEXT_COMPLETION_THRESHOLD = 0.95f
+ const val COLUMN_INTERNAL_PROVIDER_ID = "internal_provider_id"
+ const val COLUMN_TITLE = "title"
+ const val COLUMN_DESCRIPTION = "description"
+ const val COLUMN_POSTER_ART_URI = "poster_art_uri"
+ const val COLUMN_INTENT_URI = "intent_uri"
+ const val COLUMN_LAST_PLAYBACK_POSITION_MILLIS = "last_playback_position_millis"
+ const val COLUMN_DURATION_MILLIS = "duration_millis"
+ const val COLUMN_LAST_ENGAGEMENT_TIME_UTC_MILLIS = "last_engagement_time_utc_millis"
+ const val COLUMN_WATCH_NEXT_TYPE = "watch_next_type"
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.kt b/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.kt
new file mode 100644
index 00000000..d040dcd2
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.kt
@@ -0,0 +1,181 @@
+package com.streamvault.app.tvinput
+
+import android.content.ContentUris
+import android.content.Context
+import android.media.tv.TvInputManager
+import android.media.tv.TvInputService
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.Surface
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.okhttp.OkHttpDataSource
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.dash.DashMediaSource
+import androidx.media3.exoplayer.hls.HlsMediaSource
+import androidx.media3.exoplayer.rtsp.RtspMediaSource
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.exoplayer.source.ProgressiveMediaSource
+import com.streamvault.domain.model.Channel
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.StreamType
+import com.streamvault.domain.repository.ChannelRepository
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class StreamVaultTvInputService : TvInputService() {
+
+ @Inject
+ lateinit var channelRepository: ChannelRepository
+
+ @Inject
+ lateinit var okHttpClient: OkHttpClient
+
+ override fun onCreateSession(inputId: String): Session = StreamVaultSession(this)
+
+ private inner class StreamVaultSession(context: Context) : Session(context) {
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+ private val player: ExoPlayer = ExoPlayer.Builder(context).build().apply {
+ addListener(object : Player.Listener {
+ override fun onPlaybackStateChanged(playbackState: Int) {
+ when (playbackState) {
+ Player.STATE_READY -> notifyVideoAvailable()
+ Player.STATE_BUFFERING -> notifyVideoUnavailable(TvInputManager.VIDEO_UNAVAILABLE_REASON_TUNING)
+ Player.STATE_IDLE, Player.STATE_ENDED -> Unit
+ }
+ }
+ })
+ }
+
+ private val mainHandler = Handler(Looper.getMainLooper())
+
+ override fun onTune(channelUri: Uri): Boolean {
+ notifyVideoUnavailable(TvInputManager.VIDEO_UNAVAILABLE_REASON_TUNING)
+ scope.launch {
+ tune(channelUri)
+ }
+ return true
+ }
+
+ override fun onSetSurface(surface: Surface?): Boolean {
+ player.setVideoSurface(surface)
+ return true
+ }
+
+ override fun onSetStreamVolume(volume: Float) {
+ player.volume = volume
+ }
+
+ override fun onSetCaptionEnabled(enabled: Boolean) = Unit
+
+ override fun onRelease() {
+ scope.cancel()
+ player.release()
+ }
+
+ private suspend fun tune(channelUri: Uri) {
+ val channelRef = withContext(Dispatchers.IO) { loadChannelRef(channelUri) }
+ if (channelRef == null) {
+ notifyVideoUnavailable(TvInputManager.VIDEO_UNAVAILABLE_REASON_UNKNOWN)
+ return
+ }
+
+ val channel = channelRepository.getChannel(channelRef.channelId)
+ if (channel == null) {
+ notifyVideoUnavailable(TvInputManager.VIDEO_UNAVAILABLE_REASON_UNKNOWN)
+ return
+ }
+
+ val streamInfo = channelRepository.getStreamInfo(channel).getOrNull()
+ if (streamInfo == null) {
+ notifyVideoUnavailable(TvInputManager.VIDEO_UNAVAILABLE_REASON_UNKNOWN)
+ return
+ }
+
+ notifyContentAllowed()
+ notifyChannelRetuned(channelUri)
+ val mediaSource = buildMediaSource(streamInfo)
+ player.setMediaSource(mediaSource)
+ player.prepare()
+ player.playWhenReady = true
+ }
+
+ private fun buildMediaSource(streamInfo: StreamInfo): MediaSource {
+ val streamType = inferStreamType(streamInfo)
+ val mediaItem = MediaItem.fromUri(streamInfo.url)
+ return when (streamType) {
+ StreamType.HLS -> HlsMediaSource.Factory(buildHttpDataSource(streamInfo)).createMediaSource(mediaItem)
+ StreamType.DASH -> DashMediaSource.Factory(buildHttpDataSource(streamInfo)).createMediaSource(mediaItem)
+ StreamType.RTSP -> RtspMediaSource.Factory().createMediaSource(mediaItem)
+ StreamType.MPEG_TS,
+ StreamType.PROGRESSIVE,
+ StreamType.UNKNOWN -> ProgressiveMediaSource.Factory(buildHttpDataSource(streamInfo)).createMediaSource(mediaItem)
+ }
+ }
+
+ private fun buildHttpDataSource(streamInfo: StreamInfo): DataSource.Factory {
+ return OkHttpDataSource.Factory(okHttpClient).apply {
+ setUserAgent(streamInfo.userAgent ?: DEFAULT_USER_AGENT)
+ setDefaultRequestProperties(streamInfo.headers)
+ }
+ }
+
+ private fun inferStreamType(streamInfo: StreamInfo): StreamType {
+ if (streamInfo.streamType != StreamType.UNKNOWN) return streamInfo.streamType
+ val url = streamInfo.url.lowercase()
+ return when {
+ url.endsWith(".m3u8") -> StreamType.HLS
+ url.endsWith(".mpd") -> StreamType.DASH
+ url.startsWith("rtsp") -> StreamType.RTSP
+ url.endsWith(".ts") -> StreamType.MPEG_TS
+ else -> StreamType.PROGRESSIVE
+ }
+ }
+
+ private fun loadChannelRef(channelUri: Uri): ChannelRef? {
+ val resolvedUri = if (ContentUris.parseId(channelUri) > 0) channelUri else return null
+ return contentResolver.query(
+ resolvedUri,
+ arrayOf(CHANNEL_COLUMN_INTERNAL_PROVIDER_DATA),
+ null,
+ null,
+ null
+ )?.use { cursor ->
+ if (!cursor.moveToFirst()) return@use null
+ val rawData = cursor.getString(cursor.getColumnIndexOrThrow(CHANNEL_COLUMN_INTERNAL_PROVIDER_DATA))
+ decodeChannelRef(rawData)
+ }
+ }
+
+ private fun decodeChannelRef(rawData: String?): ChannelRef? {
+ val parts = rawData?.split(ENTRY_SEPARATOR).orEmpty()
+ if (parts.size < 2) return null
+ val providerId = parts[0].toLongOrNull() ?: return null
+ val channelId = parts[1].toLongOrNull() ?: return null
+ return ChannelRef(providerId = providerId, channelId = channelId)
+ }
+ }
+
+ private data class ChannelRef(
+ val providerId: Long,
+ val channelId: Long
+ )
+
+ private companion object {
+ const val TAG = "StreamVaultTvInput"
+ const val DEFAULT_USER_AGENT = "StreamVaultTvInput"
+ const val CHANNEL_COLUMN_INTERNAL_PROVIDER_DATA = "internal_provider_data"
+ const val ENTRY_SEPARATOR = ":"
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.kt b/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.kt
new file mode 100644
index 00000000..5c61e497
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.kt
@@ -0,0 +1,235 @@
+package com.streamvault.app.tvinput
+
+import android.content.ComponentName
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.content.ContentValues
+import android.content.Context
+import android.content.Intent
+import android.media.tv.TvContract
+import android.provider.BaseColumns
+import android.util.Log
+import com.streamvault.app.MainActivity
+import com.streamvault.app.navigation.PlayerNavigationRequest
+import com.streamvault.domain.model.Channel
+import com.streamvault.domain.model.Program
+import com.streamvault.domain.repository.ChannelRepository
+import com.streamvault.domain.repository.EpgRepository
+import com.streamvault.domain.repository.ProviderRepository
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class TvInputChannelSyncManager @Inject constructor(
+ @ApplicationContext private val context: Context,
+ private val providerRepository: ProviderRepository,
+ private val channelRepository: ChannelRepository,
+ private val epgRepository: EpgRepository
+) {
+
+ suspend fun refreshTvInputCatalog() = withContext(Dispatchers.IO) {
+ runCatching {
+ val provider = providerRepository.getActiveProvider().first()
+ if (provider == null) {
+ deleteManagedChannels()
+ return@runCatching
+ }
+
+ val channels = channelRepository.getChannels(provider.id).first()
+ val existingChannelIds = loadExistingChannels()
+ val targetKeys = channels.mapTo(mutableSetOf(), ::channelKey)
+
+ existingChannelIds
+ .filterKeys { it !in targetKeys }
+ .values
+ .forEach(::deleteChannel)
+
+ val programsByEpgId = loadPrograms(provider.id, channels)
+
+ channels.forEach { channel ->
+ val key = channelKey(channel)
+ val channelId = existingChannelIds[key] ?: insertChannel(provider.id, channel) ?: return@forEach
+ updateChannel(channelId, provider.id, channel)
+ replacePrograms(
+ channelId = channelId,
+ programs = programsByEpgId[channel.epgChannelId].orEmpty(),
+ providerId = provider.id,
+ channel = channel
+ )
+ }
+ }.onFailure { throwable ->
+ Log.w(TAG, "TV input catalog sync failed", throwable)
+ }
+ }
+
+ private suspend fun loadPrograms(providerId: Long, channels: List<Channel>): Map<String, List<Program>> {
+ val epgIds = channels.mapNotNull { it.epgChannelId?.takeIf(String::isNotBlank) }
+ if (epgIds.isEmpty()) return emptyMap()
+
+ val now = System.currentTimeMillis()
+ val start = now - PROGRAM_LOOKBACK_MS
+ val end = now + PROGRAM_LOOKAHEAD_MS
+ val merged = mutableMapOf<String, List<Program>>()
+
+ epgIds.distinct().chunked(EPG_QUERY_CHUNK_SIZE).forEach { chunk ->
+ merged += epgRepository.getProgramsForChannels(providerId, chunk, start, end).first()
+ }
+ return merged
+ }
+
+ private fun loadExistingChannels(): Map<String, Long> {
+ val targetInputId = inputId()
+ return context.contentResolver.query(
+ TvContract.Channels.CONTENT_URI,
+ arrayOf(BaseColumns._ID, CHANNEL_COLUMN_INPUT_ID, CHANNEL_COLUMN_INTERNAL_PROVIDER_ID),
+ null,
+ null,
+ null
+ )?.use { cursor ->
+ val idIndex = cursor.getColumnIndexOrThrow(BaseColumns._ID)
+ val inputIdIndex = cursor.getColumnIndexOrThrow(CHANNEL_COLUMN_INPUT_ID)
+ val keyIndex = cursor.getColumnIndexOrThrow(CHANNEL_COLUMN_INTERNAL_PROVIDER_ID)
+ buildMap {
+ while (cursor.moveToNext()) {
+ if (cursor.getString(inputIdIndex) == targetInputId) {
+ put(cursor.getString(keyIndex), cursor.getLong(idIndex))
+ }
+ }
+ }
+ }.orEmpty()
+ }
+
+ private fun insertChannel(providerId: Long, channel: Channel): Long? {
+ val uri = context.contentResolver.insert(
+ TvContract.Channels.CONTENT_URI,
+ buildChannelValues(providerId, channel)
+ ) ?: return null
+ return ContentUris.parseId(uri)
+ }
+
+ private fun updateChannel(channelId: Long, providerId: Long, channel: Channel) {
+ context.contentResolver.update(
+ ContentUris.withAppendedId(TvContract.Channels.CONTENT_URI, channelId),
+ buildChannelValues(providerId, channel),
+ null,
+ null
+ )
+ }
+
+ private fun replacePrograms(channelId: Long, programs: List<Program>, providerId: Long, channel: Channel) {
+ val resolver = context.contentResolver
+ resolver.query(
+ TvContract.buildProgramsUriForChannel(channelId),
+ arrayOf(BaseColumns._ID),
+ null,
+ null,
+ null
+ )?.use { cursor ->
+ val idIndex = cursor.getColumnIndexOrThrow(BaseColumns._ID)
+ while (cursor.moveToNext()) {
+ resolver.delete(
+ ContentUris.withAppendedId(TvContract.Programs.CONTENT_URI, cursor.getLong(idIndex)),
+ null,
+ null
+ )
+ }
+ }
+
+ programs
+ .sortedBy { it.startTime }
+ .take(MAX_PROGRAMS_PER_CHANNEL)
+ .forEach { program ->
+ resolver.insert(
+ TvContract.Programs.CONTENT_URI,
+ buildProgramValues(channelId, providerId, channel, program)
+ )
+ }
+ }
+
+ private fun buildChannelValues(providerId: Long, channel: Channel): ContentValues = ContentValues().apply {
+ put(CHANNEL_COLUMN_INPUT_ID, inputId())
+ put(CHANNEL_COLUMN_TYPE, TvContract.Channels.TYPE_OTHER)
+ put(CHANNEL_COLUMN_SERVICE_TYPE, TvContract.Channels.SERVICE_TYPE_AUDIO_VIDEO)
+ put(CHANNEL_COLUMN_DISPLAY_NUMBER, channel.number.toString())
+ put(CHANNEL_COLUMN_DISPLAY_NAME, channel.name)
+ put(CHANNEL_COLUMN_DESCRIPTION, channel.categoryName ?: "IPTV")
+ put(CHANNEL_COLUMN_BROWSABLE, 1)
+ put(CHANNEL_COLUMN_INTERNAL_PROVIDER_ID, channelKey(channel))
+ put(CHANNEL_COLUMN_INTERNAL_PROVIDER_DATA, encodeChannelData(providerId, channel))
+ put(CHANNEL_COLUMN_APP_LINK_INTENT_URI, buildChannelIntent(channel).toUri(Intent.URI_INTENT_SCHEME))
+ }
+
+ private fun buildProgramValues(channelId: Long, providerId: Long, channel: Channel, program: Program): ContentValues = ContentValues().apply {
+ put(PROGRAM_COLUMN_CHANNEL_ID, channelId)
+ put(PROGRAM_COLUMN_TITLE, program.title)
+ put(PROGRAM_COLUMN_DESCRIPTION, program.description)
+ put(PROGRAM_COLUMN_START_TIME_UTC_MILLIS, program.startTime)
+ put(PROGRAM_COLUMN_END_TIME_UTC_MILLIS, program.endTime)
+ put(PROGRAM_COLUMN_INTERNAL_PROVIDER_DATA, "${providerId}:${channel.id}:${program.startTime}")
+ }
+
+ private fun buildChannelIntent(channel: Channel): Intent =
+ Intent(context, MainActivity::class.java)
+ .setAction(Intent.ACTION_VIEW)
+ .putExtra(
+ MainActivity.EXTRA_PLAYER_REQUEST,
+ PlayerNavigationRequest(
+ streamUrl = channel.streamUrl,
+ title = channel.name,
+ channelId = channel.epgChannelId,
+ internalId = channel.id,
+ categoryId = channel.categoryId,
+ providerId = channel.providerId,
+ contentType = "LIVE"
+ )
+ )
+ .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+ private fun deleteManagedChannels() {
+ loadExistingChannels().values.forEach(::deleteChannel)
+ }
+
+ private fun deleteChannel(channelId: Long) {
+ context.contentResolver.delete(
+ ContentUris.withAppendedId(TvContract.Channels.CONTENT_URI, channelId),
+ null,
+ null
+ )
+ }
+
+ private fun inputId(): String = ComponentName(context, StreamVaultTvInputService::class.java).flattenToShortString()
+
+ private fun channelKey(channel: Channel): String = "${channel.providerId}:${channel.id}"
+
+ private fun encodeChannelData(providerId: Long, channel: Channel): String =
+ listOf(providerId, channel.id, channel.epgChannelId.orEmpty()).joinToString(ENTRY_SEPARATOR)
+
+ private companion object {
+ const val TAG = "TvInputChannelSync"
+ const val CHANNEL_COLUMN_INPUT_ID = "input_id"
+ const val CHANNEL_COLUMN_TYPE = "type"
+ const val CHANNEL_COLUMN_SERVICE_TYPE = "service_type"
+ const val CHANNEL_COLUMN_DISPLAY_NUMBER = "display_number"
+ const val CHANNEL_COLUMN_DISPLAY_NAME = "display_name"
+ const val CHANNEL_COLUMN_DESCRIPTION = "description"
+ const val CHANNEL_COLUMN_BROWSABLE = "browsable"
+ const val CHANNEL_COLUMN_INTERNAL_PROVIDER_ID = "internal_provider_id"
+ const val CHANNEL_COLUMN_INTERNAL_PROVIDER_DATA = "internal_provider_data"
+ const val CHANNEL_COLUMN_APP_LINK_INTENT_URI = "app_link_intent_uri"
+ const val PROGRAM_COLUMN_CHANNEL_ID = "channel_id"
+ const val PROGRAM_COLUMN_TITLE = "title"
+ const val PROGRAM_COLUMN_DESCRIPTION = "description"
+ const val PROGRAM_COLUMN_START_TIME_UTC_MILLIS = "start_time_utc_millis"
+ const val PROGRAM_COLUMN_END_TIME_UTC_MILLIS = "end_time_utc_millis"
+ const val PROGRAM_COLUMN_INTERNAL_PROVIDER_DATA = "internal_provider_data"
+ const val EPG_QUERY_CHUNK_SIZE = 200
+ const val MAX_PROGRAMS_PER_CHANNEL = 24
+ const val PROGRAM_LOOKBACK_MS = 3 * 60 * 60 * 1000L
+ const val PROGRAM_LOOKAHEAD_MS = 18 * 60 * 60 * 1000L
+ const val ENTRY_SEPARATOR = ":"
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/ui/accessibility/MotionPreferences.kt b/app/src/main/java/com/streamvault/app/ui/accessibility/MotionPreferences.kt
new file mode 100644
index 00000000..31ad7442
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/ui/accessibility/MotionPreferences.kt
@@ -0,0 +1,44 @@
+package com.streamvault.app.ui.accessibility
+
+import android.content.Context
+import android.database.ContentObserver
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+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.platform.LocalContext
+
+fun isReducedMotionEnabled(context: Context): Boolean {
+ val animatorScale = runCatching {
+ Settings.Global.getFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f)
+ }.getOrDefault(1f)
+ return animatorScale == 0f
+}
+
+@Composable
+fun rememberReducedMotionEnabled(): Boolean {
+ val context = LocalContext.current
+ var reducedMotionEnabled by remember(context) {
+ mutableStateOf(isReducedMotionEnabled(context))
+ }
+
+ DisposableEffect(context) {
+ val observer = object : ContentObserver(Handler(Looper.getMainLooper())) {
+ override fun onChange(selfChange: Boolean) {
+ reducedMotionEnabled = isReducedMotionEnabled(context)
+ }
+ }
+ val uri = Settings.Global.getUriFor(Settings.Global.ANIMATOR_DURATION_SCALE)
+ context.contentResolver.registerContentObserver(uri, false, observer)
+ onDispose {
+ context.contentResolver.unregisterContentObserver(observer)
+ }
+ }
+
+ return reducedMotionEnabled
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/streamvault/app/ui/components/AsyncImageModels.kt b/app/src/main/java/com/streamvault/app/ui/components/AsyncImageModels.kt
index dc41d22c..444877c6 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/AsyncImageModels.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/AsyncImageModels.kt
@@ -3,17 +3,19 @@ package com.streamvault.app.ui.components
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.LocalContext
+import com.streamvault.app.ui.accessibility.rememberReducedMotionEnabled
import coil3.request.ImageRequest
import coil3.request.crossfade
@Composable
fun rememberCrossfadeImageModel(data: Any?): Any? {
val context = LocalContext.current
- return remember(context, data) {
+ val reducedMotionEnabled = rememberReducedMotionEnabled()
+ return remember(context, data, reducedMotionEnabled) {
data?.let {
ImageRequest.Builder(context)
.data(it)
- .crossfade(true)
+ .crossfade(!reducedMotionEnabled)
.build()
}
}
diff --git a/app/src/main/java/com/streamvault/app/ui/components/Cards.kt b/app/src/main/java/com/streamvault/app/ui/components/Cards.kt
index 0ea7cd54..bdb39db1 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/Cards.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/Cards.kt
@@ -18,12 +18,18 @@ import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.produceState
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.stateIn
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
@@ -33,6 +39,9 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
@@ -65,6 +74,21 @@ import com.streamvault.domain.model.Movie
import com.streamvault.domain.model.Series
import com.streamvault.app.ui.design.FocusSpec
+private object ChannelProgressTicker {
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+ val nowMs = flow {
+ while (true) {
+ emit(System.currentTimeMillis())
+ delay(30_000L)
+ }
+ }.stateIn(
+ scope = scope,
+ started = SharingStarted.WhileSubscribed(stopTimeoutMillis = 30_000L),
+ initialValue = System.currentTimeMillis()
+ )
+}
+
@Composable
fun FocusableCard(
onClick: () -> Unit,
@@ -74,6 +98,8 @@ fun FocusableCard(
height: Dp = 240.dp,
isReorderMode: Boolean = false,
isDragging: Boolean = false,
+ semanticsDescription: String? = null,
+ semanticsStateDescription: String? = null,
content: @Composable BoxScope.(Boolean) -> Unit
) {
var isFocused by remember { mutableStateOf(false) }
@@ -98,6 +124,10 @@ fun FocusableCard(
scaleX = scale
scaleY = scale
}
+ .semantics(mergeDescendants = true) {
+ semanticsDescription?.let { contentDescription = it }
+ semanticsStateDescription?.let { stateDescription = it }
+ }
.onFocusChanged { isFocused = it.isFocused },
shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(12.dp)),
scale = ClickableSurfaceDefaults.scale(
@@ -138,14 +168,29 @@ fun ChannelCard(
isReorderMode: Boolean = false,
isDragging: Boolean = false
) {
- // Ticks every 30s so EPG progress bars stay accurate without busy-looping
- val nowMs by produceState(initialValue = System.currentTimeMillis()) {
- while (true) {
- delay(30_000L)
- value = System.currentTimeMillis()
+ val nowMs by ChannelProgressTicker.nowMs.collectAsState()
+ val channelCardShape = LocalAppShapes.current.small
+ val channelDescription = buildString {
+ append(
+ channel.number.takeIf { it > 0 }?.let {
+ stringResource(R.string.a11y_channel_with_number, it, channel.name)
+ } ?: channel.name
+ )
+ if (!isLocked) {
+ channel.currentProgram?.title?.takeIf { it.isNotBlank() }?.let {
+ append(". ")
+ append(stringResource(R.string.a11y_now_playing, it))
+ }
+ if (channel.isFavorite) {
+ append(". ")
+ append(stringResource(R.string.a11y_favorite))
+ }
+ if (channel.catchUpSupported) {
+ append(". ")
+ append(stringResource(R.string.a11y_catch_up_available))
+ }
}
}
- val channelCardShape = LocalAppShapes.current.small
FocusableCard(
onClick = onClick,
onLongClick = onLongClick,
@@ -153,7 +198,9 @@ fun ChannelCard(
width = 220.dp,
height = 124.dp,
isReorderMode = isReorderMode,
- isDragging = isDragging
+ isDragging = isDragging,
+ semanticsDescription = channelDescription,
+ semanticsStateDescription = if (isLocked) stringResource(R.string.a11y_locked) else null
) { isFocused ->
if (!isLocked) {
ChannelLogoBadge(
@@ -266,6 +313,17 @@ fun MovieCard(
isReorderMode: Boolean = false,
isDragging: Boolean = false
) {
+ val movieDescription = buildString {
+ append(movie.name)
+ movie.year?.takeIf { it.isNotBlank() }?.let {
+ append(". ")
+ append(it)
+ }
+ if (movie.isFavorite && !isLocked) {
+ append(". ")
+ append(stringResource(R.string.a11y_favorite))
+ }
+ }
FocusableCard(
onClick = onClick,
onLongClick = onLongClick,
@@ -273,7 +331,9 @@ fun MovieCard(
width = 136.dp,
height = 204.dp,
isReorderMode = isReorderMode,
- isDragging = isDragging
+ isDragging = isDragging,
+ semanticsDescription = movieDescription,
+ semanticsStateDescription = if (isLocked) stringResource(R.string.a11y_locked) else null
) {
if (!isLocked) {
MoviePosterCard(
@@ -347,6 +407,20 @@ fun SeriesCard(
isReorderMode: Boolean = false,
isDragging: Boolean = false
) {
+ val seriesDescription = buildString {
+ append(series.name)
+ subtitle?.takeIf { it.isNotBlank() }?.let {
+ append(". ")
+ append(it)
+ } ?: series.genre?.takeIf { it.isNotBlank() }?.let {
+ append(". ")
+ append(it)
+ }
+ if (series.isFavorite && !isLocked) {
+ append(". ")
+ append(stringResource(R.string.a11y_favorite))
+ }
+ }
FocusableCard(
onClick = onClick,
onLongClick = onLongClick,
@@ -354,7 +428,9 @@ fun SeriesCard(
width = 136.dp,
height = 204.dp,
isReorderMode = isReorderMode,
- isDragging = isDragging
+ isDragging = isDragging,
+ semanticsDescription = seriesDescription,
+ semanticsStateDescription = if (isLocked) stringResource(R.string.a11y_locked) else null
) {
if (!isLocked) {
SeriesPosterCard(
diff --git a/app/src/main/java/com/streamvault/app/ui/components/SearchInput.kt b/app/src/main/java/com/streamvault/app/ui/components/SearchInput.kt
index ca5c4d78..0e31f3c9 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/SearchInput.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/SearchInput.kt
@@ -30,6 +30,9 @@ import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.unit.dp
import androidx.tv.material3.Icon
@@ -71,12 +74,16 @@ fun SearchInput(
.height(40.dp)
.background(backgroundColor, RoundedCornerShape(8.dp))
.border(borderWidth, borderColor, RoundedCornerShape(8.dp))
+ .semantics(mergeDescendants = true) {
+ contentDescription = placeholder
+ stateDescription = value.ifBlank { placeholder }
+ }
.onFocusChanged {
isFocused = enabled && it.hasFocus
}
.focusProperties {
canFocus = enabled
- enter = { focusRequester }
+ onEnter = { focusRequester }
}
.clickable(enabled = enabled) {
focusRequester.requestFocus()
@@ -89,7 +96,7 @@ fun SearchInput(
Row(verticalAlignment = Alignment.CenterVertically) {
Icon(
imageVector = Icons.Default.Search,
- contentDescription = placeholder,
+ contentDescription = null,
tint = if (isFocused) Primary else OnSurfaceDim,
modifier = Modifier.padding(end = 6.dp)
)
diff --git a/app/src/main/java/com/streamvault/app/ui/components/SkeletonLoader.kt b/app/src/main/java/com/streamvault/app/ui/components/SkeletonLoader.kt
index cd20064a..ecd81b11 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/SkeletonLoader.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/SkeletonLoader.kt
@@ -18,11 +18,13 @@ import androidx.compose.ui.node.ModifierNodeElement
import androidx.compose.ui.node.invalidateDraw
import androidx.compose.ui.platform.InspectorInfo
import androidx.compose.ui.unit.dp
+import com.streamvault.app.ui.accessibility.rememberReducedMotionEnabled
import kotlinx.coroutines.Job
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
-fun Modifier.shimmerEffect(baseColor: Color): Modifier = this.then(ShimmerElement(baseColor))
+fun Modifier.shimmerEffect(baseColor: Color, enabled: Boolean = true): Modifier =
+ if (enabled) this.then(ShimmerElement(baseColor)) else this
private data class ShimmerElement(
private val baseColor: Color
@@ -101,10 +103,11 @@ private class ShimmerNode(
fun SkeletonCard(modifier: Modifier = Modifier) {
val bgColor = MaterialTheme.colorScheme.surfaceVariant
val shimmerBaseColor = MaterialTheme.colorScheme.onSurface
+ val reducedMotionEnabled = rememberReducedMotionEnabled()
Box(
modifier = modifier
.background(bgColor, RoundedCornerShape(8.dp))
- .shimmerEffect(baseColor = shimmerBaseColor)
+ .shimmerEffect(baseColor = shimmerBaseColor, enabled = !reducedMotionEnabled)
)
}
@@ -117,13 +120,14 @@ fun SkeletonRow(
) {
val bgColor = MaterialTheme.colorScheme.surfaceVariant
val shimmerBaseColor = MaterialTheme.colorScheme.onSurface
+ val reducedMotionEnabled = rememberReducedMotionEnabled()
Column(modifier = modifier.padding(vertical = 16.dp)) {
Box(
modifier = Modifier
.width(150.dp)
.height(24.dp)
.background(bgColor, RoundedCornerShape(4.dp))
- .shimmerEffect(baseColor = shimmerBaseColor)
+ .shimmerEffect(baseColor = shimmerBaseColor, enabled = !reducedMotionEnabled)
.padding(horizontal = 16.dp, vertical = 8.dp)
)
Spacer(modifier = Modifier.height(16.dp))
diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt
index af88a330..3526014a 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt
@@ -23,6 +23,7 @@ import com.streamvault.app.ui.theme.ErrorColor
import com.streamvault.app.ui.theme.FocusBorder
import com.streamvault.app.ui.theme.Primary
import com.streamvault.app.ui.theme.SurfaceElevated
+import com.streamvault.app.ui.design.requestFocusSafely
import kotlinx.coroutines.delay
import androidx.compose.ui.res.stringResource
import com.streamvault.app.R
@@ -46,7 +47,7 @@ fun PinDialog(
val firstKeyFocusRequester = remember { FocusRequester() }
LaunchedEffect(Unit) {
- runCatching { firstKeyFocusRequester.requestFocus() }
+ firstKeyFocusRequester.requestFocusSafely(tag = "PinDialog", target = "PIN keypad")
delay(500)
canInteract = true
}
diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/RenameGroupDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/RenameGroupDialog.kt
index b026c096..0a4ca1c9 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/dialogs/RenameGroupDialog.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/RenameGroupDialog.kt
@@ -38,6 +38,7 @@ import androidx.tv.material3.MaterialTheme
import androidx.tv.material3.Surface
import androidx.tv.material3.SurfaceDefaults
import androidx.tv.material3.Text
+import com.streamvault.app.ui.design.requestFocusSafely
import com.streamvault.app.ui.design.FocusSpec
import com.streamvault.app.R
import com.streamvault.app.ui.theme.FocusBorder
@@ -59,7 +60,7 @@ fun RenameGroupDialog(
val keyboardController = LocalSoftwareKeyboardController.current
LaunchedEffect(Unit) {
- runCatching { focusRequester.requestFocus() }
+ focusRequester.requestFocusSafely(tag = "RenameGroupDialog", target = "Rename group field")
keyboardController?.show()
delay(500)
canInteract = true
diff --git a/app/src/main/java/com/streamvault/app/ui/components/shell/AppMediaCards.kt b/app/src/main/java/com/streamvault/app/ui/components/shell/AppMediaCards.kt
index 4b5061d5..4036acd4 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/shell/AppMediaCards.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/shell/AppMediaCards.kt
@@ -36,6 +36,9 @@ import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
import androidx.tv.material3.Border
import androidx.tv.material3.ClickableSurfaceDefaults
import androidx.tv.material3.MaterialTheme
@@ -181,6 +184,28 @@ fun LiveChannelRowSurface(
rowHeight: Dp = 68.dp
) {
var isFocused by remember { mutableStateOf(false) }
+ val favoriteLabel = stringResource(R.string.a11y_favorite)
+ val catchUpLabel = stringResource(R.string.a11y_catch_up_available)
+ val lockedLabel = stringResource(R.string.a11y_locked)
+ val channelDescription = buildString {
+ append(
+ channel.number.takeIf { it > 0 }?.let {
+ stringResource(R.string.a11y_channel_with_number, it, channel.name)
+ } ?: channel.name
+ )
+ channel.currentProgram?.title?.takeIf { it.isNotBlank() }?.let {
+ append(". ")
+ append(stringResource(R.string.a11y_now_playing, it))
+ }
+ if (channel.isFavorite) {
+ append(". ")
+ append(favoriteLabel)
+ }
+ if (channel.catchUpSupported) {
+ append(". ")
+ append(catchUpLabel)
+ }
+ }
val scale by animateFloatAsState(
targetValue = if (isDragging) FocusSpec.FocusedScale else 1f,
animationSpec = AppMotion.FocusSpec,
@@ -196,6 +221,12 @@ fun LiveChannelRowSurface(
scaleX = scale
scaleY = scale
}
+ .semantics(mergeDescendants = true) {
+ contentDescription = channelDescription
+ if (isLocked) {
+ stateDescription = lockedLabel
+ }
+ }
.onFocusChanged { isFocused = it.isFocused },
shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(16.dp)),
colors = ClickableSurfaceDefaults.colors(
diff --git a/app/src/main/java/com/streamvault/app/ui/components/shell/AppShell.kt b/app/src/main/java/com/streamvault/app/ui/components/shell/AppShell.kt
index 449d3dcc..05f5323a 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/shell/AppShell.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/shell/AppShell.kt
@@ -50,6 +50,10 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.heading
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
@@ -242,7 +246,7 @@ private fun TopNavigationBar(
Surface(
modifier = modifier.focusProperties {
- enter = {
+ onEnter = {
val activeItem = items.firstOrNull { it.route == currentRoute }
focusRequesters[activeItem?.route] ?: FocusRequester.Default
}
@@ -419,7 +423,8 @@ fun AppSectionHeader(
Text(
text = title,
style = MaterialTheme.typography.titleMedium,
- color = AppColors.TextPrimary
+ color = AppColors.TextPrimary,
+ modifier = Modifier.semantics { heading() }
)
if (!subtitle.isNullOrBlank()) {
Text(
@@ -492,7 +497,7 @@ fun AppMessageState(
) {
val resolvedShape = shape ?: LocalAppShapes.current.large
Surface(
- modifier = modifier,
+ modifier = modifier.semantics { liveRegion = LiveRegionMode.Polite },
shape = resolvedShape,
border = Border(
border = BorderStroke(
@@ -626,7 +631,7 @@ private fun DestinationRail(
)
)
.focusProperties {
- enter = {
+ onEnter = {
val activeItem = items.firstOrNull { it.route == currentRoute }
focusRequesters[activeItem?.route] ?: FocusRequester.Default
}
diff --git a/app/src/main/java/com/streamvault/app/ui/design/FocusHelpers.kt b/app/src/main/java/com/streamvault/app/ui/design/FocusHelpers.kt
index 34f77da3..b4523f4f 100644
--- a/app/src/main/java/com/streamvault/app/ui/design/FocusHelpers.kt
+++ b/app/src/main/java/com/streamvault/app/ui/design/FocusHelpers.kt
@@ -1,5 +1,6 @@
package com.streamvault.app.ui.design
+import android.util.Log
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
@@ -14,6 +15,18 @@ import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LocalLifecycleOwner
+private const val FOCUS_TAG = "FocusHelpers"
+
+fun FocusRequester.requestFocusSafely(tag: String = FOCUS_TAG, target: String = "Focus target"): Boolean {
+ return try {
+ requestFocus()
+ true
+ } catch (e: IllegalStateException) {
+ Log.d(tag, "$target focus request failed: ${e.message}")
+ false
+ }
+}
+
@Composable
fun TvInitialFocus(
focusRequester: FocusRequester,
@@ -21,7 +34,7 @@ fun TvInitialFocus(
) {
LaunchedEffect(focusRequester, enabled) {
if (enabled) {
- runCatching { focusRequester.requestFocus() }
+ focusRequester.requestFocusSafely(target = "Initial TV focus")
}
}
}
diff --git a/app/src/main/java/com/streamvault/app/ui/design/FocusSpec.kt b/app/src/main/java/com/streamvault/app/ui/design/FocusSpec.kt
index 9752ba3c..25bdd4d5 100644
--- a/app/src/main/java/com/streamvault/app/ui/design/FocusSpec.kt
+++ b/app/src/main/java/com/streamvault/app/ui/design/FocusSpec.kt
@@ -5,6 +5,6 @@ import androidx.compose.ui.unit.dp
object FocusSpec {
const val FocusedScale = 1.06f
const val PressedScale = 0.98f
- val BorderWidth = 2.dp
- val CardBorderWidth = 3.dp
+ val BorderWidth = 3.dp
+ val CardBorderWidth = 4.dp
}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardScreen.kt
index 2d55bcb3..4ac25be6 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardScreen.kt
@@ -33,7 +33,7 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.Border
import androidx.tv.material3.Button
import androidx.tv.material3.ButtonDefaults
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.kt
index 55a43f91..bc0bb608 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.kt
@@ -115,7 +115,7 @@ class DashboardViewModel @Inject constructor(
movieCount = movieCount,
seriesCount = seriesCount
)
- }.combine(syncManager.syncState.onStart { emit(SyncState.Idle) }) { snapshot, syncState ->
+ }.combine(syncManager.syncStateForProvider(provider.id).onStart { emit(SyncState.Idle) }) { snapshot, syncState ->
DashboardUiState(
provider = provider,
favoriteChannels = snapshot.shelves.favoriteChannels,
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt
index b5107ed1..7629e565 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt
@@ -51,7 +51,7 @@ import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.Dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.Border
import androidx.tv.material3.Button
import androidx.tv.material3.ButtonDefaults
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/favorites/FavoritesScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/favorites/FavoritesScreen.kt
index bf831c8d..05de3566 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/favorites/FavoritesScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/favorites/FavoritesScreen.kt
@@ -46,7 +46,7 @@ import androidx.compose.ui.input.key.type
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.Border
import androidx.tv.material3.ClickableSurfaceDefaults
import androidx.tv.material3.MaterialTheme
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt
index f276ba05..c7b59c32 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt
@@ -6,8 +6,6 @@ import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.foundation.border
import androidx.compose.foundation.background
@@ -32,7 +30,7 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.*
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
@@ -52,8 +50,6 @@ import com.streamvault.app.ui.components.dialogs.PremiumDialog
import com.streamvault.app.ui.components.dialogs.PremiumDialogFooterButton
import com.streamvault.app.ui.components.dialogs.RenameGroupDialog
import com.streamvault.app.ui.components.ReorderTopBar
-import com.streamvault.app.ui.components.SkeletonCard
-import com.streamvault.app.ui.components.shimmerEffect
import com.streamvault.app.ui.components.shell.AppNavigationChrome
import com.streamvault.app.ui.components.shell.AppScreenScaffold
import com.streamvault.app.ui.design.FocusRestoreHost
@@ -82,6 +78,29 @@ private enum class FocusRestoreTarget {
CHANNEL
}
+@Composable
+private fun HomeLoadingPane(
+ message: String,
+ modifier: Modifier = Modifier
+) {
+ Box(
+ modifier = modifier.fillMaxSize(),
+ contentAlignment = Alignment.Center
+ ) {
+ Column(
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(16.dp)
+ ) {
+ CircularProgressIndicator(color = Color.White)
+ Text(
+ text = message,
+ color = Color.White.copy(alpha = 0.7f),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+ }
+}
+
// ── Screen ─────────────────────────────────────────────────────────
@@ -260,46 +279,29 @@ fun HomeScreen(
)
}
- if (uiState.isLoading && uiState.categories.isEmpty()) {
+ if (uiState.isCategoriesLoading && uiState.categories.isEmpty()) {
Row(modifier = Modifier.fillMaxSize()) {
- // Sidebar skeleton
- Column(
+ Box(
modifier = Modifier
.width(272.dp)
.fillMaxHeight()
.background(SurfaceElevated)
- .padding(vertical = 16.dp, horizontal = 16.dp)
+ .padding(horizontal = 16.dp, vertical = 24.dp)
) {
- repeat(10) {
- Box(
- modifier = Modifier
- .fillMaxWidth()
- .height(48.dp)
- .padding(vertical = 4.dp)
- .background(Color.DarkGray, RoundedCornerShape(8.dp))
- .shimmerEffect(baseColor = MaterialTheme.colorScheme.onSurface)
- )
- }
+ HomeLoadingPane(
+ message = stringResource(R.string.home_loading_categories)
+ )
}
- // Content skeleton
- Column(
+
+ Box(
modifier = Modifier
.weight(1f)
.fillMaxHeight()
.padding(24.dp)
) {
- LazyVerticalGrid(
- columns = GridCells.Adaptive(minSize = 180.dp),
- modifier = Modifier.fillMaxSize(),
- verticalArrangement = Arrangement.spacedBy(16.dp),
- horizontalArrangement = Arrangement.spacedBy(16.dp)
- ) {
- items(20) {
- SkeletonCard(
- modifier = Modifier.aspectRatio(16f/9f)
- )
- }
- }
+ HomeLoadingPane(
+ message = stringResource(R.string.home_loading_channels)
+ )
}
}
} else {
@@ -312,6 +314,11 @@ fun HomeScreen(
it.name.contains(uiState.categorySearchQuery, ignoreCase = true)
}
}
+ val isCategoryLocked: (Category) -> Boolean = remember(uiState.parentalControlLevel) {
+ { category ->
+ (category.isAdult || category.isUserProtected) && uiState.parentalControlLevel == 1
+ }
+ }
var lastFocusedCategoryId by rememberSaveable { mutableStateOf<Long?>(null) }
var lastFocusedChannelId by rememberSaveable { mutableStateOf<Long?>(null) }
var preferredRestoreTarget by rememberSaveable { mutableStateOf(FocusRestoreTarget.CHANNEL.name) }
@@ -321,8 +328,10 @@ fun HomeScreen(
val visibleCategoryIds = remember(visibleCategories) {
visibleCategories.mapTo(mutableSetOf()) { it.id }
}
- val displayedCategory = uiState.selectedCategory?.takeIf { it.id in visibleCategoryIds }
- ?: visibleCategories.firstOrNull()
+ val displayedCategory = uiState.selectedCategory?.takeIf {
+ it.id in visibleCategoryIds && !isCategoryLocked(it)
+ } ?: visibleCategories.firstOrNull { !isCategoryLocked(it) }
+ val hasBlockedCategorySearch = displayedCategory == null && visibleCategories.isNotEmpty()
LaunchedEffect(uiState.categories) {
val validIds = uiState.categories.mapTo(mutableSetOf()) { it.id }
@@ -334,11 +343,15 @@ fun HomeScreen(
channelFocusRequesters.keys.retainAll(validIds)
}
- LaunchedEffect(uiState.categorySearchQuery, displayedCategory?.id, isReorderMode) {
+ LaunchedEffect(uiState.categorySearchQuery, displayedCategory?.id, isReorderMode, hasBlockedCategorySearch) {
if (isReorderMode) return@LaunchedEffect
- val selectedCategory = uiState.selectedCategory ?: return@LaunchedEffect
- if (displayedCategory?.id == selectedCategory.id) return@LaunchedEffect
- displayedCategory?.let(viewModel::selectCategory)
+ if (displayedCategory == null) {
+ viewModel.clearVisibleChannelsForFilteredCategories()
+ return@LaunchedEffect
+ }
+ val selectedCategory = uiState.selectedCategory
+ if (selectedCategory?.id == displayedCategory.id) return@LaunchedEffect
+ viewModel.selectCategory(displayedCategory)
}
LaunchedEffect(
@@ -544,7 +557,7 @@ fun HomeScreen(
items = visibleCategories,
key = { it.id }
) { category ->
- val isLocked = (category.isAdult || category.isUserProtected) && uiState.parentalControlLevel == 1
+ val isLocked = isCategoryLocked(category)
val categoryFocusRequester = categoryFocusRequesters.getOrPut(category.id) { FocusRequester() }
CategoryItem(
@@ -605,7 +618,11 @@ fun HomeScreen(
verticalArrangement = Arrangement.spacedBy(if (isDenseMode) 2.dp else 4.dp)
) {
Text(
- text = displayedCategory?.name ?: stringResource(R.string.home_all_channels),
+ text = displayedCategory?.name ?: if (hasBlockedCategorySearch) {
+ stringResource(R.string.home_locked_short)
+ } else {
+ stringResource(R.string.home_all_channels)
+ },
style = if (isDenseMode) MaterialTheme.typography.titleMedium else MaterialTheme.typography.titleLarge,
color = OnBackground
)
@@ -708,29 +725,48 @@ fun HomeScreen(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(6.dp)
) {
- Text(
- text = stringResource(R.string.home_no_channels_found),
- style = MaterialTheme.typography.titleLarge,
- color = OnBackground
- )
- Text(
- text = stringResource(R.string.home_no_channels_found_subtitle),
- style = MaterialTheme.typography.bodySmall,
- color = OnSurfaceDim
- )
- val selectedCategory = uiState.selectedCategory
- if (selectedCategory?.isVirtual == true && selectedCategory.id == VirtualCategoryIds.FAVORITES) {
+ if (hasBlockedCategorySearch) {
+ Icon(
+ imageVector = Icons.Filled.Lock,
+ contentDescription = null,
+ tint = OnBackground,
+ modifier = Modifier.size(34.dp)
+ )
+ Text(
+ text = stringResource(R.string.home_locked_short),
+ style = MaterialTheme.typography.titleLarge,
+ color = OnBackground
+ )
Text(
- text = stringResource(R.string.home_add_favorites_hint),
+ text = stringResource(R.string.home_no_channels_found_subtitle),
style = MaterialTheme.typography.bodySmall,
color = OnSurfaceDim
)
- } else if (selectedCategory?.isVirtual == true && selectedCategory.id == VirtualCategoryIds.RECENT) {
+ } else {
+ Text(
+ text = stringResource(R.string.home_no_channels_found),
+ style = MaterialTheme.typography.titleLarge,
+ color = OnBackground
+ )
Text(
- text = stringResource(R.string.home_recent_channels_hint),
+ text = stringResource(R.string.home_no_channels_found_subtitle),
style = MaterialTheme.typography.bodySmall,
color = OnSurfaceDim
)
+ val selectedCategory = uiState.selectedCategory
+ if (selectedCategory?.isVirtual == true && selectedCategory.id == VirtualCategoryIds.FAVORITES) {
+ Text(
+ text = stringResource(R.string.home_add_favorites_hint),
+ style = MaterialTheme.typography.bodySmall,
+ color = OnSurfaceDim
+ )
+ } else if (selectedCategory?.isVirtual == true && selectedCategory.id == VirtualCategoryIds.RECENT) {
+ Text(
+ text = stringResource(R.string.home_recent_channels_hint),
+ style = MaterialTheme.typography.bodySmall,
+ color = OnSurfaceDim
+ )
+ }
}
}
}
@@ -904,6 +940,7 @@ fun HomeScreen(
onLaunch = {
pendingSplitPlannerChannel = null
viewModel.onDismissDialog()
+ viewModel.clearPreview()
onNavigate(Routes.MULTI_VIEW)
},
viewModel = multiViewViewModel
@@ -946,6 +983,7 @@ fun HomeScreen(
onDismiss = { showSplitManagerDialog = false },
onLaunch = {
showSplitManagerDialog = false
+ viewModel.clearPreview()
onNavigate(Routes.MULTI_VIEW)
},
viewModel = multiViewViewModel
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt
index e9073446..9f4551f6 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt
@@ -3,6 +3,7 @@ package com.streamvault.app.ui.screens.home
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.streamvault.app.di.AuxiliaryPlayerEngine
+import com.streamvault.app.tvinput.TvInputChannelSyncManager
import com.streamvault.app.ui.model.LiveTvChannelMode
import com.streamvault.data.preferences.PreferencesRepository
import com.streamvault.data.sync.SyncManager
@@ -52,6 +53,7 @@ class HomeViewModel @Inject constructor(
private val getCustomCategories: GetCustomCategories,
private val parentalControlManager: ParentalControlManager,
private val syncManager: SyncManager,
+ private val tvInputChannelSyncManager: TvInputChannelSyncManager,
@AuxiliaryPlayerEngine
private val playerEngineProvider: InjectProvider<PlayerEngine>
) : ViewModel() {
@@ -77,8 +79,23 @@ class HomeViewModel @Inject constructor(
viewModelScope.launch {
providerRepository.getActiveProvider()
.filterNotNull()
+ .distinctUntilChangedBy { it.id }
.collectLatest { provider ->
- _uiState.update { it.copy(provider = provider) }
+ _uiState.update {
+ it.copy(
+ provider = provider,
+ categories = emptyList(),
+ recentChannels = emptyList(),
+ lastVisitedCategory = null,
+ selectedCategory = null,
+ filteredChannels = emptyList(),
+ hasChannels = false,
+ isLoading = false,
+ isCategoriesLoading = true,
+ errorMessage = null
+ )
+ }
+ _localChannels.value = emptyList()
loadCategoriesAndChannels(provider.id)
observeRecentChannels(provider.id)
preferencesRepository.setLastActiveProviderId(provider.id)
@@ -165,19 +182,24 @@ class HomeViewModel @Inject constructor(
}
viewModelScope.launch {
- syncManager.syncState.collectLatest { syncState ->
- val isSyncing = syncState is SyncState.Syncing
- _uiState.update { state ->
- state.copy(
- isSyncing = isSyncing,
- isLoading = when {
- state.hasChannels -> false
- isSyncing && state.selectedCategory != null -> true
- else -> state.isLoading && isSyncing
- }
- )
+ _uiState.map { it.provider?.id }
+ .distinctUntilChanged()
+ .flatMapLatest { providerId ->
+ providerId?.let { syncManager.syncStateForProvider(it) } ?: flowOf(SyncState.Idle)
+ }
+ .collectLatest { syncState ->
+ val isSyncing = syncState is SyncState.Syncing
+ _uiState.update { state ->
+ state.copy(
+ isSyncing = isSyncing,
+ isLoading = when {
+ state.hasChannels -> false
+ isSyncing && state.selectedCategory != null -> true
+ else -> state.isLoading && isSyncing
+ }
+ )
+ }
}
- }
}
}
@@ -198,82 +220,96 @@ class HomeViewModel @Inject constructor(
private fun loadCategoriesAndChannels(providerId: Long) {
categoriesJob?.cancel()
categoriesJob = viewModelScope.launch {
- combine(
- channelRepository.getCategories(providerId),
- getCustomCategories(),
- playbackHistoryRepository.getRecentlyWatchedByProvider(providerId, limit = 24),
- preferencesRepository.defaultCategoryId,
- preferencesRepository.getLastLiveCategoryId(providerId)
- ) { providerCats, customCats, history, defaultId, lastVisitedCategoryId ->
- val recentCategory = Category(
- id = VirtualCategoryIds.RECENT,
- name = "Recent",
- type = ContentType.LIVE,
- isVirtual = true,
- count = history.toRecentLiveContentIds().size
- )
-
- val orderedCategories = buildList {
- val favoritesCategory = customCats.find { it.id == VirtualCategoryIds.FAVORITES }
- if (favoritesCategory != null) {
- add(favoritesCategory)
- }
- add(recentCategory)
- addAll(
- customCats.filter { it.id != VirtualCategoryIds.FAVORITES }
+ try {
+ _uiState.update { it.copy(isCategoriesLoading = true, errorMessage = null) }
+ combine(
+ channelRepository.getCategories(providerId),
+ getCustomCategories(),
+ preferencesRepository.defaultCategoryId,
+ preferencesRepository.getLastLiveCategoryId(providerId)
+ ) { providerCats, customCats, defaultId, lastVisitedCategoryId ->
+ val recentCategory = Category(
+ id = VirtualCategoryIds.RECENT,
+ name = "Recent",
+ type = ContentType.LIVE,
+ isVirtual = true,
+ count = _uiState.value.recentChannels.size
)
- addAll(providerCats)
- }
-
- CategorySelectionContext(
- categories = orderedCategories,
- defaultCategoryId = defaultId,
- lastVisitedCategoryId = lastVisitedCategoryId
- )
- }.collect { selectionContext ->
- val categories = selectionContext.categories
- val defaultId = selectionContext.defaultCategoryId
- val preferredCategoryId = _preferredInitialCategoryId.value
- val lastVisitedCategory = selectionContext.lastVisitedCategoryId?.let { lastVisitedId ->
- categories.find { it.id == lastVisitedId && it.id != VirtualCategoryIds.RECENT }
- }
- _uiState.update { it.copy(categories = categories, lastVisitedCategory = lastVisitedCategory) }
- val currentSelected = _uiState.value.selectedCategory
- val preferredCategory = preferredCategoryId?.let { categoryId ->
- categories.find { it.id == categoryId }
- }
+ val orderedCategories = buildList {
+ val favoritesCategory = customCats.find { it.id == VirtualCategoryIds.FAVORITES }
+ if (favoritesCategory != null) {
+ add(favoritesCategory)
+ }
+ add(recentCategory)
+ addAll(customCats.filter { it.id != VirtualCategoryIds.FAVORITES })
+ addAll(providerCats)
+ }
- if (preferredCategory != null && currentSelected?.id != preferredCategory.id) {
- _preferredInitialCategoryId.value = null
- selectCategory(preferredCategory)
- return@collect
- }
+ CategorySelectionContext(
+ categories = orderedCategories,
+ defaultCategoryId = defaultId,
+ lastVisitedCategoryId = lastVisitedCategoryId
+ )
+ }.collect { selectionContext ->
+ val categories = selectionContext.categories
+ val defaultId = selectionContext.defaultCategoryId
+ val preferredCategoryId = _preferredInitialCategoryId.value
+ val lastVisitedCategory = selectionContext.lastVisitedCategoryId?.let { lastVisitedId ->
+ categories.find { it.id == lastVisitedId && it.id != VirtualCategoryIds.RECENT }
+ }
+ _uiState.update {
+ it.copy(
+ categories = categories,
+ lastVisitedCategory = lastVisitedCategory,
+ isCategoriesLoading = false
+ )
+ }
- if (currentSelected == null && categories.isNotEmpty()) {
- val defaultCat = defaultId?.let { id -> categories.find { it.id == id } }
- val favoritesCat = categories.find { it.id == VirtualCategoryIds.FAVORITES }
+ val currentSelected = _uiState.value.selectedCategory
+ val preferredCategory = preferredCategoryId?.let { categoryId ->
+ categories.find { it.id == categoryId }
+ }
- if (defaultCat != null) selectCategory(defaultCat)
- else if (favoritesCat != null) selectCategory(favoritesCat)
- else selectCategory(categories.first())
- } else if (currentSelected != null) {
- val reselectedCat = categories.find { it.id == currentSelected.id }
+ if (preferredCategory != null && currentSelected?.id != preferredCategory.id) {
+ _preferredInitialCategoryId.value = null
+ selectCategory(preferredCategory)
+ return@collect
+ }
- if (reselectedCat != null) {
- if (reselectedCat != currentSelected) {
- _uiState.update { it.copy(selectedCategory = reselectedCat) }
- }
- loadChannelsForCategory(reselectedCat)
- } else {
+ if (currentSelected == null && categories.isNotEmpty()) {
val defaultCat = defaultId?.let { id -> categories.find { it.id == id } }
val favoritesCat = categories.find { it.id == VirtualCategoryIds.FAVORITES }
if (defaultCat != null) selectCategory(defaultCat)
else if (favoritesCat != null) selectCategory(favoritesCat)
- else if (categories.isNotEmpty()) selectCategory(categories.first())
+ else selectCategory(categories.first())
+ } else if (currentSelected != null) {
+ val reselectedCat = categories.find { it.id == currentSelected.id }
+
+ if (reselectedCat != null) {
+ if (reselectedCat != currentSelected) {
+ _uiState.update { it.copy(selectedCategory = reselectedCat) }
+ }
+ } else {
+ val defaultCat = defaultId?.let { id -> categories.find { it.id == id } }
+ val favoritesCat = categories.find { it.id == VirtualCategoryIds.FAVORITES }
+
+ if (defaultCat != null) selectCategory(defaultCat)
+ else if (favoritesCat != null) selectCategory(favoritesCat)
+ else if (categories.isNotEmpty()) selectCategory(categories.first())
+ }
}
}
+ } catch (e: CancellationException) {
+ throw e
+ } catch (e: Exception) {
+ _uiState.update {
+ it.copy(
+ isCategoriesLoading = false,
+ errorMessage = appContext.getString(R.string.home_error_load_failed)
+ )
+ }
}
}
}
@@ -397,6 +433,19 @@ class HomeViewModel @Inject constructor(
_uiState.update { it.copy(categorySearchQuery = query) }
}
+ fun clearVisibleChannelsForFilteredCategories() {
+ clearPreview()
+ _localChannels.value = emptyList()
+ _uiState.update {
+ it.copy(
+ filteredChannels = emptyList(),
+ hasChannels = false,
+ isLoading = false,
+ errorMessage = null
+ )
+ }
+ }
+
fun updateChannelSearchQuery(query: String) {
if (_uiState.value.isChannelReorderMode) return
_uiState.update { it.copy(channelSearchQuery = query) }
@@ -449,10 +498,10 @@ class HomeViewModel @Inject constructor(
}
viewModelScope.launch {
- when (val result = channelRepository.getStreamUrl(channel)) {
+ when (val result = channelRepository.getStreamInfo(channel)) {
is Result.Success -> {
engine.stop()
- engine.prepare(StreamInfo(url = result.data))
+ engine.prepare(result.data)
engine.setVolume(0f)
engine.play()
}
@@ -581,7 +630,18 @@ class HomeViewModel @Inject constructor(
.flatMapLatest { ids -> loadChannelsByOrderedIds(ids) }
.collect { channels ->
_uiState.update { it.copy(recentChannels = channels) }
+ updateRecentCategoryCount(channels.size)
+ }
+ }
+ }
+
+ private fun updateRecentCategoryCount(count: Int) {
+ _uiState.update { state ->
+ state.copy(
+ categories = state.categories.map { category ->
+ if (category.id == VirtualCategoryIds.RECENT) category.copy(count = count) else category
}
+ )
}
}
@@ -742,6 +802,7 @@ class HomeViewModel @Inject constructor(
viewModelScope.launch {
_uiState.update { it.copy(isLoading = true) }
providerRepository.refreshProviderData(provider.id, force = true)
+ tvInputChannelSyncManager.refreshTvInputCatalog()
_uiState.update { it.copy(isLoading = false) }
}
}
@@ -778,9 +839,14 @@ class HomeViewModel @Inject constructor(
val providerId = _uiState.value.provider?.id ?: return
viewModelScope.launch {
val newStatus = !category.isUserProtected
- categoryRepository.setCategoryProtection(providerId, category.id, category.type, newStatus)
- val msg = if (newStatus) "Locked '${category.name}'" else "Unlocked '${category.name}'"
- _uiState.update { it.copy(userMessage = msg) }
+ when (categoryRepository.setCategoryProtection(providerId, category.id, category.type, newStatus)) {
+ is Result.Success -> {
+ val msg = if (newStatus) "Locked '${category.name}'" else "Unlocked '${category.name}'"
+ _uiState.update { it.copy(userMessage = msg) }
+ }
+ is Result.Error -> _uiState.update { it.copy(userMessage = "Failed to update category lock") }
+ Result.Loading -> Unit
+ }
}
}
@@ -935,6 +1001,7 @@ data class HomeUiState(
val filteredChannels: List<Channel> = emptyList(),
val hasChannels: Boolean = false,
val isLoading: Boolean = true,
+ val isCategoriesLoading: Boolean = true,
val isSyncing: Boolean = false,
val categorySearchQuery: String = "",
val channelSearchQuery: String = "",
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt
index 1e632ff6..7def9f2d 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt
@@ -15,7 +15,7 @@ import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.*
import androidx.compose.ui.layout.ContentScale
import coil3.compose.AsyncImage
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt
index 49e08249..1c4e94f5 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt
@@ -69,7 +69,7 @@ class MoviesViewModel @Inject constructor(
.filterNotNull()
.flatMapLatest { provider ->
combine(
- favoriteRepository.getAllFavorites(ContentType.MOVIE),
+ favoriteRepository.getFavorites(ContentType.MOVIE),
getCustomCategories(ContentType.MOVIE),
movieRepository.getCategories(provider.id),
movieRepository.getCategoryItemCounts(provider.id),
@@ -134,7 +134,7 @@ class MoviesViewModel @Inject constructor(
.filterNotNull()
.flatMapLatest { provider ->
combine(
- favoriteRepository.getAllFavorites(ContentType.MOVIE),
+ favoriteRepository.getFavorites(ContentType.MOVIE),
getCustomCategories(ContentType.MOVIE),
movieRepository.getCategories(provider.id),
movieRepository.getCategoryItemCounts(provider.id)
@@ -208,7 +208,7 @@ class MoviesViewModel @Inject constructor(
.filterNotNull()
.flatMapLatest { provider ->
combine(
- favoriteRepository.getAllFavorites(ContentType.MOVIE),
+ favoriteRepository.getFavorites(ContentType.MOVIE),
playbackHistoryRepository.getRecentlyWatchedByProvider(provider.id, limit = 24),
movieRepository.getTopRatedPreview(provider.id, PREVIEW_ROW_LIMIT),
movieRepository.getFreshPreview(provider.id, PREVIEW_ROW_LIMIT)
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewManager.kt b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewManager.kt
index 6c932f93..0c520fa2 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewManager.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewManager.kt
@@ -23,7 +23,14 @@ class MultiViewManager @Inject constructor() {
/** Place a channel in a specific slot index (0–3). Replaces whatever was there. */
fun setChannel(slotIndex: Int, channel: Channel) {
if (slotIndex !in 0 until MAX_SLOTS) return
- _slots.value = _slots.value.toMutableList().also { it[slotIndex] = channel }
+ _slots.value = _slots.value.toMutableList().also { slots ->
+ slots.indices.forEach { index ->
+ if (index != slotIndex && slots[index]?.id == channel.id) {
+ slots[index] = null
+ }
+ }
+ slots[slotIndex] = channel
+ }
}
/** Clear a specific slot. */
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewPlannerDialog.kt b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewPlannerDialog.kt
index 4fe93089..fdee8592 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewPlannerDialog.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewPlannerDialog.kt
@@ -20,12 +20,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.compose.runtime.collectAsState
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.compose.runtime.getValue
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.compose.runtime.mutableStateOf
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.compose.runtime.remember
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
@@ -36,7 +31,7 @@ import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.Border
import androidx.tv.material3.ClickableSurfaceDefaults
import androidx.tv.material3.MaterialTheme
@@ -62,7 +57,7 @@ fun MultiViewPlannerDialog(
val slots by viewModel.slotsFlow.collectAsStateWithLifecycle()
val isPickerMode = pendingChannel != null
val hasAny = slots.any { it != null }
- var channelPlaced by remember { mutableStateOf(false) }
+ val channelPlaced = pendingChannel != null && slots.any { it?.id == pendingChannel.id }
val firstSlotFocusRequester = remember { FocusRequester() }
LaunchedEffect(Unit) {
@@ -71,10 +66,10 @@ fun MultiViewPlannerDialog(
}
val subtitle = when {
- isPickerMode && !channelPlaced && pendingChannel != null ->
- stringResource(R.string.multiview_planner_pick_slot, pendingChannel.name)
- channelPlaced && pendingChannel != null ->
- stringResource(R.string.multiview_planner_added, pendingChannel.name)
+ isPickerMode && !channelPlaced ->
+ stringResource(R.string.multiview_planner_pick_slot, pendingChannel!!.name)
+ channelPlaced ->
+ stringResource(R.string.multiview_planner_added, pendingChannel!!.name)
hasAny ->
stringResource(R.string.multiview_planner_ready_subtitle)
else ->
@@ -118,9 +113,9 @@ fun MultiViewPlannerDialog(
else Modifier
),
onSlotClick = {
- if (pendingChannel != null && isPickerMode && !channelPlaced) {
- viewModel.assignChannelToSlot(slotIndex, pendingChannel)
- channelPlaced = true
+ val channelToPlace = pendingChannel ?: return@MultiViewSlotCard
+ if (isPickerMode && !channelPlaced) {
+ viewModel.assignChannelToSlot(slotIndex, channelToPlace)
}
},
onClearSlot = { viewModel.clearSlot(slotIndex) }
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewScreen.kt
index d40a0011..d7bccf25 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewScreen.kt
@@ -52,7 +52,7 @@ import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.compose.ui.res.stringResource
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.media3.common.util.UnstableApi
import androidx.tv.material3.Border
import androidx.tv.material3.ClickableSurfaceDefaults
@@ -298,6 +298,18 @@ private fun PlayerCell(
fontSize = 11.sp,
textAlign = TextAlign.Center
)
+ if (!slot.errorMessage.isNullOrBlank()) {
+ Spacer(modifier = Modifier.height(6.dp))
+ Text(
+ text = slot.errorMessage,
+ color = Color(0xFFFFB3B3),
+ fontSize = 10.sp,
+ textAlign = TextAlign.Center,
+ modifier = Modifier.padding(horizontal = 12.dp),
+ maxLines = 3,
+ overflow = TextOverflow.Ellipsis
+ )
+ }
}
}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewState.kt b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewState.kt
index 266d43af..4c4160fe 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewState.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewState.kt
@@ -59,6 +59,7 @@ data class MultiViewSlot(
val playerEngine: PlayerEngine? = null,
val isLoading: Boolean = false,
val hasError: Boolean = false,
+ val errorMessage: String? = null,
val isAudioPinned: Boolean = false,
val performanceBlockedReason: String? = null
) {
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewViewModel.kt
index 44cbc1bc..311d28b2 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/multiview/MultiViewViewModel.kt
@@ -7,13 +7,14 @@ import android.os.PowerManager
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.streamvault.app.di.AuxiliaryPlayerEngine
-import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
import com.streamvault.data.preferences.PreferencesRepository
import com.streamvault.domain.model.Channel
-import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.Result
+import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.repository.ChannelRepository
import com.streamvault.domain.repository.FavoriteRepository
import com.streamvault.domain.repository.PlaybackHistoryRepository
+import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.player.PlayerEngine
import dagger.hilt.android.lifecycle.HiltViewModel
import dagger.hilt.android.qualifiers.ApplicationContext
@@ -37,7 +38,7 @@ class MultiViewViewModel @Inject constructor(
private val channelRepository: ChannelRepository,
private val favoriteRepository: FavoriteRepository,
private val playbackHistoryRepository: PlaybackHistoryRepository,
- private val xtreamStreamUrlResolver: XtreamStreamUrlResolver
+ private val providerRepository: ProviderRepository
) : ViewModel() {
private val _uiState = MutableStateFlow(MultiViewUiState())
@@ -51,11 +52,13 @@ class MultiViewViewModel @Inject constructor(
private var thermalStatus: MultiViewThermalStatus = readThermalStatus()
private var thermalListener: PowerManager.OnThermalStatusChangedListener? = null
private var runtimeActiveSlotLimit: Int = MultiViewManager.MAX_SLOTS
+ private var activeProviderConnectionLimit: Int? = null
private var sustainedStressSamples: Int = 0
private var stableSamples: Int = 0
private var lastPolicyAdjustmentAt: Long = 0L
private val lastDroppedFramesBySlot = mutableMapOf<Int, Int>()
private val slotStartupJobs = mutableMapOf<Int, kotlinx.coroutines.Job>()
+ private val slotErrorJobs = mutableMapOf<Int, kotlinx.coroutines.Job>()
private var slotInitVersion: Long = 0L
/** Flow of the current 4 slot channels from the manager */
@@ -107,6 +110,21 @@ class MultiViewViewModel @Inject constructor(
}
}
+ viewModelScope.launch {
+ providerRepository.getActiveProvider().collect { provider ->
+ val nextConnectionLimit = provider
+ ?.takeIf { it.type == ProviderType.XTREAM_CODES }
+ ?.maxConnections
+ ?.coerceAtLeast(1)
+ if (activeProviderConnectionLimit != nextConnectionLimit) {
+ activeProviderConnectionLimit = nextConnectionLimit
+ if (multiViewManager.hasAnyChannel) {
+ initSlots()
+ }
+ }
+ }
+ }
+
registerThermalListener()
observeReplacementCandidates()
}
@@ -116,15 +134,27 @@ class MultiViewViewModel @Inject constructor(
val initVersion = ++slotInitVersion
telemetryJob?.cancel()
cancelSlotStartupJobs()
+ cancelSlotErrorJobs()
playerEngines.values.forEach { it.release() }
playerEngines.clear()
lastDroppedFramesBySlot.clear()
val channels = multiViewManager.slots.value
- val maxActiveSlots = runtimeActiveSlotLimit
+ val deviceActiveSlotLimit = runtimeActiveSlotLimit
.coerceAtLeast(1)
.coerceAtMost(_uiState.value.performancePolicy.maxActiveSlots)
+ val providerConnectionLimit = activeProviderConnectionLimit
+ val maxActiveSlots = providerConnectionLimit
+ ?.let { deviceActiveSlotLimit.coerceAtMost(it) }
+ ?: deviceActiveSlotLimit
val slots = channels.mapIndexed { index, channel ->
if (channel != null) {
+ val performanceBlockedReason = when {
+ index < maxActiveSlots -> null
+ providerConnectionLimit != null && providerConnectionLimit < deviceActiveSlotLimit ->
+ "Held back by the provider connection limit (${providerConnectionLimit} stream(s) max)."
+ else ->
+ "Held back by ${_uiState.value.performancePolicy.mode.name.lowercase()} policy on this device tier."
+ }
MultiViewSlot(
index = index,
channel = channel,
@@ -132,11 +162,7 @@ class MultiViewViewModel @Inject constructor(
title = channel.name,
isLoading = index < maxActiveSlots,
isAudioPinned = pinnedAudioSlotIndex == index,
- performanceBlockedReason = if (index >= maxActiveSlots) {
- "Held back by ${_uiState.value.performancePolicy.mode.name.lowercase()} policy on this device tier."
- } else {
- null
- }
+ performanceBlockedReason = performanceBlockedReason
)
} else {
MultiViewSlot(index = index)
@@ -175,33 +201,51 @@ class MultiViewViewModel @Inject constructor(
val engine = playerEngineProvider.get()
// Cap each multi-view slot to 720p so slots don't compete for 4K bandwidth
(engine as? com.streamvault.player.Media3PlayerEngine)
- ?.let { it.constrainResolutionForMultiView = true }
+ ?.let {
+ it.constrainResolutionForMultiView = true
+ it.bypassAudioFocus = true
+ it.enableMediaSession = false
+ }
if (initVersion != slotInitVersion) {
engine.release()
return@launch
}
playerEngines[index] = engine
+ observeSlotErrors(index, engine, initVersion)
+
+ val channel = slot.channel
+ ?: throw IllegalStateException("Missing channel for slot ${slot.index}")
+ val streamInfo = when (val result = channelRepository.getStreamInfo(channel)) {
+ is Result.Success -> result.data
+ is Result.Error -> throw IllegalStateException(result.message)
+ Result.Loading -> throw IllegalStateException("Stream info still loading for ${slot.title}")
+ }
- val resolvedUrl = xtreamStreamUrlResolver.resolve(
- url = slot.streamUrl,
- fallbackProviderId = slot.channel?.providerId,
- fallbackStreamId = slot.channel?.streamId,
- fallbackContentType = ContentType.LIVE
- ) ?: throw IllegalStateException("No playable URL for ${slot.title}")
-
- engine.prepare(
- com.streamvault.domain.model.StreamInfo(url = resolvedUrl)
- )
+ engine.prepare(streamInfo)
engine.play()
// Copy the engine into the slot UI state as well
- updateSlot(index) { it.copy(isLoading = false, playerEngine = engine) }
+ updateSlot(index) {
+ it.copy(
+ isLoading = false,
+ hasError = false,
+ errorMessage = null,
+ playerEngine = engine
+ )
+ }
// Re-apply audio to make sure the focused one is audible
applyFocusAudio(_uiState.value.focusedSlotIndex)
} catch (e: Exception) {
if (initVersion == slotInitVersion) {
- updateSlot(index) { it.copy(isLoading = false, hasError = true) }
+ updateSlot(index) {
+ it.copy(
+ isLoading = false,
+ hasError = true,
+ errorMessage = e.message,
+ playerEngine = playerEngines[index]
+ )
+ }
}
} finally {
slotStartupJobs.remove(index)
@@ -368,6 +412,7 @@ class MultiViewViewModel @Inject constructor(
telemetryJob?.cancel()
borderHideJob?.cancel()
cancelSlotStartupJobs()
+ cancelSlotErrorJobs()
unregisterThermalListener()
playerEngines.values.forEach { it.release() }
playerEngines.clear()
@@ -378,6 +423,30 @@ class MultiViewViewModel @Inject constructor(
slotStartupJobs.clear()
}
+ private fun cancelSlotErrorJobs() {
+ slotErrorJobs.values.forEach { job -> job.cancel() }
+ slotErrorJobs.clear()
+ }
+
+ private fun observeSlotErrors(index: Int, engine: PlayerEngine, initVersion: Long) {
+ slotErrorJobs.remove(index)?.cancel()
+ slotErrorJobs[index] = viewModelScope.launch {
+ engine.error.collect { error ->
+ if (initVersion != slotInitVersion) return@collect
+ if (error != null) {
+ updateSlot(index) { current ->
+ current.copy(
+ isLoading = false,
+ hasError = true,
+ errorMessage = error.message,
+ playerEngine = engine
+ )
+ }
+ }
+ }
+ }
+ }
+
private fun detectDeviceTier(): DevicePerformanceTier {
val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
val memoryClass = activityManager?.memoryClass ?: 256
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt
index 0d94a8d3..b27b77f3 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt
@@ -64,6 +64,8 @@ import androidx.compose.ui.res.stringResource
import androidx.lifecycle.Lifecycle
import com.streamvault.app.R
import com.streamvault.app.MainActivity
+import com.streamvault.app.cast.CastConnectionState
+import com.streamvault.app.ui.design.requestFocusSafely
import com.streamvault.app.ui.screens.player.overlay.ChannelInfoOverlay
import com.streamvault.app.ui.screens.player.overlay.CategoryListOverlay
import com.streamvault.app.ui.screens.player.overlay.ChannelListOverlay
@@ -89,6 +91,7 @@ import com.streamvault.app.navigation.Routes
fun PlayerScreen(
streamUrl: String,
title: String,
+ artworkUrl: String? = null,
epgChannelId: String? = null,
internalChannelId: Long = -1L,
categoryId: Long? = null,
@@ -146,6 +149,7 @@ fun PlayerScreen(
val currentChannelRecording by viewModel.currentChannelRecording.collectAsStateWithLifecycle()
val isMuted by viewModel.isMuted.collectAsStateWithLifecycle()
val mediaTitle by viewModel.mediaTitle.collectAsStateWithLifecycle()
+ val castConnectionState by viewModel.castConnectionState.collectAsStateWithLifecycle()
var showTrackSelection by remember { mutableStateOf<TrackType?>(null) }
var showProgramHistory by remember { mutableStateOf(false) }
@@ -219,17 +223,15 @@ fun PlayerScreen(
if (anyOverlayVisible) {
// Give overlays a moment to animate in before requesting focus
delay(150)
- try {
- when {
- showCategoryListOverlay -> categoryListFocusRequester.requestFocus()
- showChannelListOverlay -> channelListFocusRequester.requestFocus()
- showEpgOverlay -> epgFocusRequester.requestFocus()
- showChannelInfoOverlay -> channelInfoFocusRequester.requestFocus()
- }
- } catch (_: Exception) {}
+ when {
+ showCategoryListOverlay -> categoryListFocusRequester.requestFocusSafely(tag = "PlayerScreen", target = "Category list overlay")
+ showChannelListOverlay -> channelListFocusRequester.requestFocusSafely(tag = "PlayerScreen", target = "Channel list overlay")
+ showEpgOverlay -> epgFocusRequester.requestFocusSafely(tag = "PlayerScreen", target = "EPG overlay")
+ showChannelInfoOverlay -> channelInfoFocusRequester.requestFocusSafely(tag = "PlayerScreen", target = "Channel info overlay")
+ }
} else {
// Restore focus to main player when all overlays are gone
- try { focusRequester.requestFocus() } catch (_: Exception) {}
+ focusRequester.requestFocusSafely(tag = "PlayerScreen", target = "Player root")
}
}
@@ -262,13 +264,14 @@ fun PlayerScreen(
onDismiss = { showSplitDialog = false },
onLaunch = {
showSplitDialog = false
+ viewModel.handOffPlaybackToMultiView()
onNavigate?.invoke(Routes.MULTI_VIEW)
},
viewModel = multiViewViewModel
)
}
- LaunchedEffect(streamUrl, epgChannelId, title, internalChannelId, categoryId, providerId, isVirtual, contentType, archiveStartMs, archiveEndMs, archiveTitle) {
+ LaunchedEffect(streamUrl, epgChannelId, title, artworkUrl, internalChannelId, categoryId, providerId, isVirtual, contentType, archiveStartMs, archiveEndMs, archiveTitle) {
viewModel.prepare(
streamUrl = streamUrl,
epgChannelId = epgChannelId,
@@ -278,6 +281,7 @@ fun PlayerScreen(
isVirtual = isVirtual,
contentType = contentType,
title = title,
+ artworkUrl = artworkUrl,
archiveStartMs = archiveStartMs,
archiveEndMs = archiveEndMs,
archiveTitle = archiveTitle
@@ -287,16 +291,14 @@ fun PlayerScreen(
LaunchedEffect(showControls) {
if (showControls) {
delay(100)
- try {
- if (contentType == "LIVE") {
- quickActionsFocusRequester.requestFocus()
- } else {
- playButtonFocusRequester.requestFocus()
- }
- } catch (_: Exception) {}
+ if (contentType == "LIVE") {
+ quickActionsFocusRequester.requestFocusSafely(tag = "PlayerScreen", target = "Player quick actions")
+ } else {
+ playButtonFocusRequester.requestFocusSafely(tag = "PlayerScreen", target = "Player transport")
+ }
viewModel.hideControlsAfterDelay()
} else {
- try { focusRequester.requestFocus() } catch (_: Exception) {}
+ focusRequester.requestFocusSafely(tag = "PlayerScreen", target = "Player root")
}
}
@@ -324,6 +326,22 @@ fun PlayerScreen(
.onKeyEvent { event ->
// Only handle KeyDown to avoid double actions
if (event.nativeKeyEvent.action == KeyEvent.ACTION_DOWN) {
+ if (showTrackSelection != null) {
+ return@onKeyEvent when (event.nativeKeyEvent.keyCode) {
+ KeyEvent.KEYCODE_BACK -> {
+ showTrackSelection = null
+ true
+ }
+ KeyEvent.KEYCODE_DPAD_UP,
+ KeyEvent.KEYCODE_DPAD_DOWN,
+ KeyEvent.KEYCODE_DPAD_LEFT,
+ KeyEvent.KEYCODE_DPAD_RIGHT,
+ KeyEvent.KEYCODE_DPAD_CENTER,
+ KeyEvent.KEYCODE_ENTER,
+ KeyEvent.KEYCODE_NUMPAD_ENTER -> false
+ else -> true
+ }
+ }
when (event.nativeKeyEvent.keyCode) {
KeyEvent.KEYCODE_DPAD_CENTER, KeyEvent.KEYCODE_ENTER -> {
if (showChannelListOverlay || showEpgOverlay || showChannelInfoOverlay || showDiagnostics) {
@@ -331,18 +349,23 @@ fun PlayerScreen(
}
if (contentType == "LIVE" && viewModel.hasPendingNumericChannelInput()) {
viewModel.commitNumericChannelInput()
+ true
} else if (contentType == "LIVE") {
- if (showChannelInfoOverlay) viewModel.closeChannelInfoOverlay()
- else viewModel.openChannelInfoOverlay()
+ if (showChannelInfoOverlay) viewModel.closeChannelInfoOverlay()
+ else viewModel.openChannelInfoOverlay()
+ true
+ } else if (showControls) {
+ false
} else {
viewModel.toggleControls()
+ true
}
- true
}
KeyEvent.KEYCODE_DPAD_LEFT -> {
if (showChannelListOverlay || showCategoryListOverlay || showEpgOverlay || showChannelInfoOverlay || showDiagnostics) {
viewModel.onLiveOverlayInteraction()
}
+ if (showControls && contentType != "LIVE") return@onKeyEvent false
if (showChannelListOverlay && contentType == "LIVE") {
// Second left press while channel list is open β†’ open category list
viewModel.openCategoryListOverlay()
@@ -361,6 +384,7 @@ fun PlayerScreen(
if (showChannelListOverlay || showEpgOverlay || showChannelInfoOverlay || showDiagnostics) {
viewModel.onLiveOverlayInteraction()
}
+ if (showControls && contentType != "LIVE") return@onKeyEvent false
if (contentType == "LIVE" && !showChannelListOverlay && !showEpgOverlay && !showChannelInfoOverlay) {
if (isRtl) viewModel.openChannelListOverlay() else viewModel.openEpgOverlay()
true
@@ -376,6 +400,7 @@ fun PlayerScreen(
viewModel.onLiveOverlayInteraction()
}
if (showChannelListOverlay || showCategoryListOverlay || showEpgOverlay) return@onKeyEvent false
+ if (showControls && contentType != "LIVE") return@onKeyEvent false
if (contentType == "LIVE") {
viewModel.playNext()
@@ -389,6 +414,7 @@ fun PlayerScreen(
viewModel.onLiveOverlayInteraction()
}
if (showChannelListOverlay || showCategoryListOverlay || showEpgOverlay) return@onKeyEvent false
+ if (showControls && contentType != "LIVE") return@onKeyEvent false
if (contentType == "LIVE") {
viewModel.playPrevious()
@@ -619,6 +645,9 @@ fun PlayerScreen(
onOpenSplitScreen = { showSplitDialog = true },
onEnterPictureInPicture = enterPictureInPicture,
onToggleMute = viewModel::toggleMute,
+ isCastConnected = castConnectionState == CastConnectionState.CONNECTED,
+ onCast = { viewModel.castCurrentMedia { mainActivity?.openCastRouteChooser() } },
+ onStopCasting = viewModel::stopCasting,
onSeekToPosition = viewModel::seekTo,
onSetScrubbingMode = viewModel::setScrubbingMode
)
@@ -793,7 +822,19 @@ fun PlayerScreen(
isPlaying = isPlaying,
currentAspectRatio = aspectRatio.modeName,
isDiagnosticsEnabled = showDiagnostics,
- onOpenSplitScreen = { showSplitDialog = true }
+ onOpenSplitScreen = { showSplitDialog = true },
+ subtitleTrackCount = availableSubtitleTracks.size,
+ audioTrackCount = availableAudioTracks.size,
+ videoQualityCount = availableVideoQualities.size,
+ isMuted = isMuted,
+ onToggleMute = viewModel::toggleMute,
+ onOpenSubtitleTracks = { showTrackSelection = TrackType.TEXT },
+ onOpenAudioTracks = { showTrackSelection = TrackType.AUDIO },
+ onOpenVideoTracks = { showTrackSelection = TrackType.VIDEO },
+ onEnterPictureInPicture = enterPictureInPicture,
+ isCastConnected = castConnectionState == CastConnectionState.CONNECTED,
+ onCast = { viewModel.castCurrentMedia { mainActivity?.openCastRouteChooser() } },
+ onStopCasting = viewModel::stopCasting
)
}
}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt
index f36b6c51..ad7d5278 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt
@@ -2,8 +2,15 @@ package com.streamvault.app.ui.screens.player
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
+import com.streamvault.app.cast.CastConnectionState
+import com.streamvault.app.cast.CastManager
+import com.streamvault.app.cast.CastMediaRequest
+import com.streamvault.app.cast.CastStartResult
import com.streamvault.app.di.MainPlayerEngine
+import com.streamvault.app.tv.LauncherRecommendationsManager
+import com.streamvault.app.tv.WatchNextManager
import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
+import com.streamvault.data.security.CredentialDecryptionException
import com.streamvault.domain.manager.RecordingManager
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.Program
@@ -88,7 +95,7 @@ enum class AspectRatio(val modeName: String) {
@HiltViewModel
@OptIn(ExperimentalCoroutinesApi::class)
class PlayerViewModel @Inject constructor(
- @MainPlayerEngine
+ @param:MainPlayerEngine
val playerEngine: PlayerEngine,
private val epgRepository: EpgRepository,
private val channelRepository: ChannelRepository,
@@ -99,6 +106,9 @@ class PlayerViewModel @Inject constructor(
private val preferencesRepository: com.streamvault.data.preferences.PreferencesRepository,
private val getCustomCategories: GetCustomCategories,
private val recordingManager: RecordingManager,
+ private val watchNextManager: WatchNextManager,
+ private val launcherRecommendationsManager: LauncherRecommendationsManager,
+ private val castManager: CastManager,
private val xtreamStreamUrlResolver: XtreamStreamUrlResolver
) : ViewModel() {
@@ -187,6 +197,15 @@ class PlayerViewModel @Inject constructor(
private var lastRecordedLivePlaybackKey: Pair<Long, Long>? = null
private var currentStreamClassLabel: String = "Primary"
private var prepareRequestVersion: Long = 0L
+ private var currentArtworkUrl: String? = null
+
+ val castConnectionState: StateFlow<CastConnectionState> = castManager.connectionState
+
+ private fun logRepositoryFailure(operation: String, result: com.streamvault.domain.model.Result<Unit>) {
+ if (result is com.streamvault.domain.model.Result.Error) {
+ android.util.Log.w("PlayerVM", "$operation failed: ${result.message}", result.exception)
+ }
+ }
init {
viewModelScope.launch {
@@ -203,7 +222,10 @@ class PlayerViewModel @Inject constructor(
zapBufferWatchdogJob?.cancel()
_currentChannel.value?.let { channel ->
if (channel.errorCount > 0) {
- channelRepository.resetChannelErrorCount(channel.id)
+ logRepositoryFailure(
+ operation = "Reset channel error count",
+ result = channelRepository.resetChannelErrorCount(channel.id)
+ )
}
}
}
@@ -248,7 +270,10 @@ class PlayerViewModel @Inject constructor(
viewModelScope.launch {
markStreamFailure(currentStreamUrl)
setLastFailureReason(error.message)
- channelRepository.incrementChannelErrorCount(channel.id)
+ logRepositoryFailure(
+ operation = "Increment channel error count",
+ result = channelRepository.incrementChannelErrorCount(channel.id)
+ )
val switched = when (recoveryType) {
PlayerRecoveryType.NETWORK,
@@ -459,6 +484,7 @@ class PlayerViewModel @Inject constructor(
isVirtual: Boolean = false,
contentType: String = "CHANNEL",
title: String = "",
+ artworkUrl: String? = null,
archiveStartMs: Long? = null,
archiveEndMs: Long? = null,
archiveTitle: String? = null
@@ -468,6 +494,7 @@ class PlayerViewModel @Inject constructor(
currentProviderId = providerId
currentContentId = internalChannelId
currentTitle = title
+ currentArtworkUrl = artworkUrl
currentContentType = try { ContentType.valueOf(contentType) } catch (e: Exception) { ContentType.LIVE }
currentStreamClassLabel = if (archiveStartMs != null && archiveEndMs != null) "Catch-up" else "Primary"
if (currentContentType != ContentType.LIVE) {
@@ -562,12 +589,21 @@ class PlayerViewModel @Inject constructor(
archiveEndMs > archiveStartMs
) {
viewModelScope.launch {
- val catchUpUrl = providerRepository.buildCatchUpUrl(
- providerId = currentProviderId,
- streamId = currentContentId,
- start = archiveStartMs / 1000L,
- end = archiveEndMs / 1000L
- )
+ val catchUpUrl = try {
+ providerRepository.buildCatchUpUrl(
+ providerId = currentProviderId,
+ streamId = currentContentId,
+ start = archiveStartMs / 1000L,
+ end = archiveEndMs / 1000L
+ )
+ } catch (e: CredentialDecryptionException) {
+ setLastFailureReason(e.message ?: CredentialDecryptionException.MESSAGE)
+ showPlayerNotice(
+ message = e.message ?: CredentialDecryptionException.MESSAGE,
+ recoveryType = PlayerRecoveryType.SOURCE
+ )
+ return@launch
+ }
if (catchUpUrl != null) {
currentTitle = archiveTitle?.takeIf { it.isNotBlank() } ?: currentTitle
currentStreamUrl = catchUpUrl
@@ -691,12 +727,18 @@ class PlayerViewModel @Inject constructor(
contentType = currentContentType,
providerId = currentProviderId,
title = currentTitle,
+ posterUrl = currentArtworkUrl,
streamUrl = currentStreamUrl,
resumePositionMs = pos,
totalDurationMs = dur,
lastWatchedAt = System.currentTimeMillis()
)
- playbackHistoryRepository.updateResumePosition(history)
+ logRepositoryFailure(
+ operation = "Persist playback resume position",
+ result = playbackHistoryRepository.updateResumePosition(history)
+ )
+ watchNextManager.refreshWatchNext()
+ launcherRecommendationsManager.refreshRecommendations()
}
}
@@ -727,6 +769,56 @@ class PlayerViewModel @Inject constructor(
}
}
+ fun handOffPlaybackToMultiView() {
+ if (currentContentType != ContentType.LIVE) {
+ viewModelScope.launch { persistPlaybackProgress() }
+ }
+ playerEngine.release()
+ }
+
+ fun castCurrentMedia(onRouteSelectionRequired: () -> Unit) {
+ viewModelScope.launch {
+ val request = buildCastRequest()
+ if (request == null) {
+ showPlayerNotice(
+ message = "This item cannot be sent to a Cast receiver.",
+ recoveryType = PlayerRecoveryType.SOURCE
+ )
+ return@launch
+ }
+
+ when (castManager.startCasting(request)) {
+ CastStartResult.STARTED -> {
+ playerEngine.pause()
+ showPlayerNotice(
+ message = "Casting to the connected device.",
+ recoveryType = PlayerRecoveryType.NETWORK
+ )
+ }
+
+ CastStartResult.ROUTE_SELECTION_REQUIRED -> onRouteSelectionRequired()
+
+ CastStartResult.UNAVAILABLE -> showPlayerNotice(
+ message = "Google Cast is unavailable on this device.",
+ recoveryType = PlayerRecoveryType.SOURCE
+ )
+
+ CastStartResult.UNSUPPORTED -> showPlayerNotice(
+ message = "This stream format is not supported by Google Cast.",
+ recoveryType = PlayerRecoveryType.SOURCE
+ )
+ }
+ }
+ }
+
+ fun stopCasting() {
+ castManager.stopCasting()
+ showPlayerNotice(
+ message = "Cast session disconnected.",
+ recoveryType = PlayerRecoveryType.NETWORK
+ )
+ }
+
private fun fetchEpg(providerId: Long, epgChannelId: String?) {
epgJob?.cancel()
if (providerId > 0 && epgChannelId != null) {
@@ -1102,14 +1194,17 @@ class PlayerViewModel @Inject constructor(
lastRecordedLivePlaybackKey = playbackKey
viewModelScope.launch {
- playbackHistoryRepository.recordPlayback(
- PlaybackHistory(
- contentId = channel.id,
- contentType = ContentType.LIVE,
- providerId = currentProviderId,
- title = channel.name,
- streamUrl = channel.streamUrl,
- lastWatchedAt = System.currentTimeMillis()
+ logRepositoryFailure(
+ operation = "Record live playback",
+ result = playbackHistoryRepository.recordPlayback(
+ PlaybackHistory(
+ contentId = channel.id,
+ contentType = ContentType.LIVE,
+ providerId = currentProviderId,
+ title = channel.name,
+ streamUrl = channel.streamUrl,
+ lastWatchedAt = System.currentTimeMillis()
+ )
)
)
}
@@ -1363,7 +1458,17 @@ class PlayerViewModel @Inject constructor(
return@launch
}
- val catchUpUrl = providerRepository.buildCatchUpUrl(providerId, streamId, start, end)
+ val catchUpUrl = try {
+ providerRepository.buildCatchUpUrl(providerId, streamId, start, end)
+ } catch (e: CredentialDecryptionException) {
+ setLastFailureReason(e.message ?: CredentialDecryptionException.MESSAGE)
+ showPlayerNotice(
+ message = e.message ?: CredentialDecryptionException.MESSAGE,
+ recoveryType = PlayerRecoveryType.SOURCE,
+ actions = buildRecoveryActions(PlayerRecoveryType.SOURCE)
+ )
+ return@launch
+ }
if (catchUpUrl != null) {
// Update metadata for player
currentTitle = "${_currentChannel.value?.name ?: ""}: ${program.title}"
@@ -1600,11 +1705,18 @@ class PlayerViewModel @Inject constructor(
providerId: Long,
contentType: ContentType
): String? {
- xtreamStreamUrlResolver.resolve(
- url = logicalUrl,
- fallbackProviderId = providerId.takeIf { it > 0 },
- fallbackContentType = contentType
- )?.let { return it }
+ try {
+ xtreamStreamUrlResolver.resolve(
+ url = logicalUrl,
+ fallbackProviderId = providerId.takeIf { it > 0 },
+ fallbackContentType = contentType
+ )?.let { return it }
+ } catch (e: CredentialDecryptionException) {
+ val message = e.message ?: CredentialDecryptionException.MESSAGE
+ setLastFailureReason(message)
+ showPlayerNotice(message = message, recoveryType = PlayerRecoveryType.SOURCE)
+ return null
+ }
if (providerId <= 0L || internalContentId <= 0L) {
return logicalUrl.takeIf { it.isNotBlank() }
@@ -1612,15 +1724,99 @@ class PlayerViewModel @Inject constructor(
return when (contentType) {
ContentType.LIVE -> channelRepository.getChannel(internalContentId)?.let { channel ->
- channelRepository.getStreamUrl(channel).getOrNull()
+ channelRepository.getStreamInfo(channel).getOrNull()?.url
}
ContentType.MOVIE -> movieRepository.getMovie(internalContentId)?.let { movie ->
- movieRepository.getStreamUrl(movie).getOrNull()
+ movieRepository.getStreamInfo(movie).getOrNull()?.url
}
ContentType.SERIES, ContentType.SERIES_EPISODE -> logicalUrl.takeIf { it.isNotBlank() }
}
}
+ private suspend fun buildCastRequest(): CastMediaRequest? {
+ return when (currentContentType) {
+ ContentType.LIVE -> {
+ val channel = _currentChannel.value ?: return null
+ val streamInfo = channelRepository.getStreamInfo(channel).getOrNull() ?: return null
+ streamInfo.toCastRequest(
+ title = mediaTitle.value ?: channel.name,
+ subtitle = _currentProgram.value?.title,
+ artworkUrl = channel.logoUrl ?: currentArtworkUrl,
+ isLive = true,
+ startPositionMs = 0L
+ )
+ }
+
+ ContentType.MOVIE -> {
+ val movie = movieRepository.getMovie(currentContentId)
+ val streamInfo = movie?.let { movieRepository.getStreamInfo(it).getOrNull() }
+ ?: return directCastRequest()
+ streamInfo.toCastRequest(
+ title = currentTitle.ifBlank { movie.name },
+ subtitle = movie.genre,
+ artworkUrl = currentArtworkUrl ?: movie.posterUrl ?: movie.backdropUrl,
+ isLive = false,
+ startPositionMs = playerEngine.currentPosition.value
+ )
+ }
+
+ ContentType.SERIES,
+ ContentType.SERIES_EPISODE -> directCastRequest()
+ }
+ }
+
+ private fun directCastRequest(): CastMediaRequest? {
+ val url = currentStreamUrl.takeIf { it.isNotBlank() } ?: return null
+ return com.streamvault.domain.model.StreamInfo(url = url).toCastRequest(
+ title = currentTitle,
+ subtitle = null,
+ artworkUrl = currentArtworkUrl,
+ isLive = false,
+ startPositionMs = playerEngine.currentPosition.value
+ )
+ }
+
+ private fun com.streamvault.domain.model.StreamInfo.toCastRequest(
+ title: String,
+ subtitle: String?,
+ artworkUrl: String?,
+ isLive: Boolean,
+ startPositionMs: Long
+ ): CastMediaRequest? {
+ val resolvedUrl = url.takeIf { it.isNotBlank() } ?: return null
+ val mimeType = when (inferCastStreamType(this)) {
+ com.streamvault.domain.model.StreamType.HLS -> "application/x-mpegURL"
+ com.streamvault.domain.model.StreamType.DASH -> "application/dash+xml"
+ com.streamvault.domain.model.StreamType.MPEG_TS -> "video/mp2t"
+ com.streamvault.domain.model.StreamType.RTSP -> return null
+ com.streamvault.domain.model.StreamType.PROGRESSIVE,
+ com.streamvault.domain.model.StreamType.UNKNOWN -> "video/*"
+ }
+ return CastMediaRequest(
+ url = resolvedUrl,
+ title = title.ifBlank { this.title ?: "StreamVault" },
+ subtitle = subtitle,
+ artworkUrl = artworkUrl,
+ mimeType = mimeType,
+ isLive = isLive,
+ startPositionMs = if (isLive) 0L else startPositionMs
+ )
+ }
+
+ private fun inferCastStreamType(streamInfo: com.streamvault.domain.model.StreamInfo): com.streamvault.domain.model.StreamType {
+ if (streamInfo.streamType != com.streamvault.domain.model.StreamType.UNKNOWN) {
+ return streamInfo.streamType
+ }
+ val url = streamInfo.url.lowercase()
+ return when {
+ url.endsWith(".m3u8") -> com.streamvault.domain.model.StreamType.HLS
+ url.endsWith(".mpd") -> com.streamvault.domain.model.StreamType.DASH
+ url.endsWith(".ts") -> com.streamvault.domain.model.StreamType.MPEG_TS
+ url.startsWith("rtsp") -> com.streamvault.domain.model.StreamType.RTSP
+ else -> com.streamvault.domain.model.StreamType.PROGRESSIVE
+ }
+ }
+
fun dismissResumePrompt(resume: Boolean) {
val prompt = _resumePrompt.value
_resumePrompt.value = ResumePromptState() // hide
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerControlsChrome.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerControlsChrome.kt
index f1fd180a..8a161406 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerControlsChrome.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerControlsChrome.kt
@@ -10,11 +10,11 @@ import androidx.compose.animation.slideInVertically
import androidx.compose.animation.slideOutHorizontally
import androidx.compose.animation.slideOutVertically
import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.FlowRow
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.fillMaxSize
@@ -24,7 +24,6 @@ import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.widthIn
-import androidx.compose.foundation.layout.paddingFromBaseline
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.PlayArrow
@@ -60,7 +59,6 @@ import androidx.tv.material3.Text
import com.streamvault.app.R
import com.streamvault.app.ui.screens.player.NumericChannelInputState
import com.streamvault.app.ui.theme.ErrorColor
-import com.streamvault.app.ui.theme.OnSurfaceDim
import com.streamvault.app.ui.theme.Primary
import com.streamvault.domain.model.Program
import com.streamvault.domain.model.RecordingStatus
@@ -110,6 +108,9 @@ fun PlayerControlsOverlay(
onOpenSplitScreen: () -> Unit,
onEnterPictureInPicture: () -> Unit,
onToggleMute: () -> Unit,
+ isCastConnected: Boolean,
+ onCast: () -> Unit,
+ onStopCasting: () -> Unit,
onSeekToPosition: (Long) -> Unit = {},
onSetScrubbingMode: (Boolean) -> Unit = {},
clockLabelOverride: String? = null,
@@ -133,6 +134,7 @@ fun PlayerControlsOverlay(
PlayerBottomBar(
title = title,
contentType = contentType,
+ isPlaying = isPlaying,
currentProgram = currentProgram,
currentChannelName = currentChannelName,
displayChannelNumber = displayChannelNumber,
@@ -145,6 +147,7 @@ fun PlayerControlsOverlay(
currentRecordingStatus = currentRecordingStatus,
isMuted = isMuted,
mediaTitle = mediaTitle,
+ playButtonFocusRequester = playButtonFocusRequester,
quickActionsFocusRequester = quickActionsFocusRequester,
modifier = Modifier.align(Alignment.BottomCenter),
onRestartProgram = onRestartProgram,
@@ -159,21 +162,15 @@ fun PlayerControlsOverlay(
onOpenSplitScreen = onOpenSplitScreen,
onEnterPictureInPicture = onEnterPictureInPicture,
onToggleMute = onToggleMute,
+ isCastConnected = isCastConnected,
+ onCast = onCast,
+ onStopCasting = onStopCasting,
+ onTogglePlayPause = onTogglePlayPause,
+ onSeekBackward = onSeekBackward,
+ onSeekForward = onSeekForward,
onSeekToPosition = onSeekToPosition,
onSetScrubbingMode = onSetScrubbingMode
)
-
- if (contentType != "LIVE") {
- PlayerTransportBar(
- isPlaying = isPlaying,
- playButtonFocusRequester = playButtonFocusRequester,
- quickActionsFocusRequester = quickActionsFocusRequester,
- onSeekBackward = onSeekBackward,
- onSeekForward = onSeekForward,
- onTogglePlayPause = onTogglePlayPause,
- modifier = Modifier.align(Alignment.Center)
- )
- }
}
}
}
@@ -430,6 +427,7 @@ private fun PlayerTopBar(
private fun PlayerBottomBar(
title: String,
contentType: String,
+ isPlaying: Boolean,
currentProgram: Program?,
currentChannelName: String?,
displayChannelNumber: Int,
@@ -442,6 +440,7 @@ private fun PlayerBottomBar(
currentRecordingStatus: RecordingStatus?,
isMuted: Boolean,
mediaTitle: String?,
+ playButtonFocusRequester: FocusRequester,
quickActionsFocusRequester: FocusRequester,
onRestartProgram: () -> Unit,
onOpenArchive: () -> Unit,
@@ -455,6 +454,12 @@ private fun PlayerBottomBar(
onOpenSplitScreen: () -> Unit,
onEnterPictureInPicture: () -> Unit,
onToggleMute: () -> Unit,
+ isCastConnected: Boolean,
+ onCast: () -> Unit,
+ onStopCasting: () -> Unit,
+ onTogglePlayPause: () -> Unit,
+ onSeekBackward: () -> Unit,
+ onSeekForward: () -> Unit,
onSeekToPosition: (Long) -> Unit,
onSetScrubbingMode: (Boolean) -> Unit,
modifier: Modifier = Modifier
@@ -462,7 +467,6 @@ private fun PlayerBottomBar(
Box(
modifier = modifier
.fillMaxWidth()
- .height(248.dp)
.background(
Brush.verticalGradient(
colors = listOf(Color.Transparent, Color.Black.copy(alpha = 0.84f))
@@ -488,54 +492,66 @@ private fun PlayerBottomBar(
)
.padding(horizontal = 24.dp, vertical = 22.dp)
) {
- if (contentType == "LIVE") {
- PlayerLiveInfo(
- currentProgram = currentProgram,
- currentChannelName = currentChannelName,
- displayChannelNumber = displayChannelNumber,
- aspectRatioLabel = aspectRatioLabel,
- subtitleTrackCount = subtitleTrackCount,
- audioTrackCount = audioTrackCount,
- videoQualityCount = videoQualityCount,
- currentRecordingStatus = currentRecordingStatus,
- isMuted = isMuted,
- mediaTitle = mediaTitle,
- quickActionsFocusRequester = quickActionsFocusRequester,
- onRestartProgram = onRestartProgram,
- onOpenArchive = onOpenArchive,
- onStartRecording = onStartRecording,
- onStopRecording = onStopRecording,
- onScheduleRecording = onScheduleRecording,
- onToggleAspectRatio = onToggleAspectRatio,
- onOpenSubtitleTracks = onOpenSubtitleTracks,
- onOpenAudioTracks = onOpenAudioTracks,
- onOpenVideoTracks = onOpenVideoTracks,
- onOpenSplitScreen = onOpenSplitScreen,
- onEnterPictureInPicture = onEnterPictureInPicture,
- onToggleMute = onToggleMute
- )
- } else if (contentType != "LIVE") {
- PlayerVodInfo(
- title = title,
- contentType = contentType,
- currentPosition = currentPosition,
- duration = duration,
- aspectRatioLabel = aspectRatioLabel,
- subtitleTrackCount = subtitleTrackCount,
- audioTrackCount = audioTrackCount,
- videoQualityCount = videoQualityCount,
- isMuted = isMuted,
- quickActionsFocusRequester = quickActionsFocusRequester,
- onSeekToPosition = onSeekToPosition,
- onSetScrubbingMode = onSetScrubbingMode,
- onToggleAspectRatio = onToggleAspectRatio,
- onOpenSubtitleTracks = onOpenSubtitleTracks,
- onOpenAudioTracks = onOpenAudioTracks,
- onOpenVideoTracks = onOpenVideoTracks,
- onEnterPictureInPicture = onEnterPictureInPicture,
- onToggleMute = onToggleMute
- )
- }
+ if (contentType == "LIVE") {
+ PlayerLiveInfo(
+ currentProgram = currentProgram,
+ currentChannelName = currentChannelName,
+ displayChannelNumber = displayChannelNumber,
+ aspectRatioLabel = aspectRatioLabel,
+ subtitleTrackCount = subtitleTrackCount,
+ audioTrackCount = audioTrackCount,
+ videoQualityCount = videoQualityCount,
+ currentRecordingStatus = currentRecordingStatus,
+ isMuted = isMuted,
+ mediaTitle = mediaTitle,
+ playButtonFocusRequester = playButtonFocusRequester,
+ quickActionsFocusRequester = quickActionsFocusRequester,
+ onRestartProgram = onRestartProgram,
+ onOpenArchive = onOpenArchive,
+ onStartRecording = onStartRecording,
+ onStopRecording = onStopRecording,
+ onScheduleRecording = onScheduleRecording,
+ onToggleAspectRatio = onToggleAspectRatio,
+ onOpenSubtitleTracks = onOpenSubtitleTracks,
+ onOpenAudioTracks = onOpenAudioTracks,
+ onOpenVideoTracks = onOpenVideoTracks,
+ onOpenSplitScreen = onOpenSplitScreen,
+ onEnterPictureInPicture = onEnterPictureInPicture,
+ onToggleMute = onToggleMute,
+ isCastConnected = isCastConnected,
+ onCast = onCast,
+ onStopCasting = onStopCasting
+ )
+ } else {
+ PlayerVodInfo(
+ title = title,
+ contentType = contentType,
+ isPlaying = isPlaying,
+ currentPosition = currentPosition,
+ duration = duration,
+ aspectRatioLabel = aspectRatioLabel,
+ subtitleTrackCount = subtitleTrackCount,
+ audioTrackCount = audioTrackCount,
+ videoQualityCount = videoQualityCount,
+ isMuted = isMuted,
+ playButtonFocusRequester = playButtonFocusRequester,
+ quickActionsFocusRequester = quickActionsFocusRequester,
+ onSeekToPosition = onSeekToPosition,
+ onSetScrubbingMode = onSetScrubbingMode,
+ onToggleAspectRatio = onToggleAspectRatio,
+ onOpenSubtitleTracks = onOpenSubtitleTracks,
+ onOpenAudioTracks = onOpenAudioTracks,
+ onOpenVideoTracks = onOpenVideoTracks,
+ onEnterPictureInPicture = onEnterPictureInPicture,
+ onToggleMute = onToggleMute,
+ isCastConnected = isCastConnected,
+ onCast = onCast,
+ onStopCasting = onStopCasting,
+ onTogglePlayPause = onTogglePlayPause,
+ onSeekBackward = onSeekBackward,
+ onSeekForward = onSeekForward
+ )
+ }
}
}
}
@@ -553,6 +569,7 @@ private fun PlayerLiveInfo(
currentRecordingStatus: RecordingStatus?,
isMuted: Boolean,
mediaTitle: String?,
+ playButtonFocusRequester: FocusRequester,
quickActionsFocusRequester: FocusRequester,
onRestartProgram: () -> Unit,
onOpenArchive: () -> Unit,
@@ -565,13 +582,20 @@ private fun PlayerLiveInfo(
onOpenVideoTracks: () -> Unit,
onOpenSplitScreen: () -> Unit,
onEnterPictureInPicture: () -> Unit,
- onToggleMute: () -> Unit
+ onToggleMute: () -> Unit,
+ isCastConnected: Boolean,
+ onCast: () -> Unit,
+ onStopCasting: () -> Unit
) {
val primaryActions = buildList {
add(PlayerActionSpec(
stringResource(if (isMuted) R.string.player_unmute else R.string.player_mute),
onToggleMute
))
+ add(PlayerActionSpec(
+ stringResource(if (isCastConnected) R.string.player_stop_casting else R.string.player_cast),
+ if (isCastConnected) onStopCasting else onCast
+ ))
add(PlayerActionSpec(stringResource(R.string.player_picture_in_picture), onEnterPictureInPicture))
if (currentProgram?.hasArchive == true) {
add(PlayerActionSpec(stringResource(R.string.player_restart), onRestartProgram))
@@ -589,7 +613,7 @@ private fun PlayerLiveInfo(
if (subtitleTrackCount > 0) {
add(PlayerActionSpec(stringResource(R.string.player_subs), onOpenSubtitleTracks))
}
- if (audioTrackCount > 1) {
+ if (audioTrackCount > 0) {
add(PlayerActionSpec(stringResource(R.string.player_audio), onOpenAudioTracks))
}
if (videoQualityCount > 1) {
@@ -677,7 +701,8 @@ private fun PlayerLiveInfo(
PlayerQuickActionRows(
primaryActions = primaryActions,
secondaryActions = secondaryActions,
- firstActionFocusRequester = quickActionsFocusRequester
+ firstActionFocusRequester = quickActionsFocusRequester,
+ primaryActionsUpFocusRequester = playButtonFocusRequester
)
}
@@ -685,6 +710,7 @@ private fun PlayerLiveInfo(
private fun PlayerVodInfo(
title: String,
contentType: String,
+ isPlaying: Boolean,
currentPosition: Long,
duration: Long,
aspectRatioLabel: String,
@@ -692,6 +718,7 @@ private fun PlayerVodInfo(
audioTrackCount: Int,
videoQualityCount: Int,
isMuted: Boolean,
+ playButtonFocusRequester: FocusRequester,
quickActionsFocusRequester: FocusRequester,
onSeekToPosition: (Long) -> Unit,
onSetScrubbingMode: (Boolean) -> Unit,
@@ -700,25 +727,48 @@ private fun PlayerVodInfo(
onOpenAudioTracks: () -> Unit,
onOpenVideoTracks: () -> Unit,
onEnterPictureInPicture: () -> Unit,
- onToggleMute: () -> Unit
+ onToggleMute: () -> Unit,
+ isCastConnected: Boolean,
+ onCast: () -> Unit,
+ onStopCasting: () -> Unit,
+ onTogglePlayPause: () -> Unit,
+ onSeekBackward: () -> Unit,
+ onSeekForward: () -> Unit
) {
+ val playbackLabel = stringResource(R.string.player_playback_label)
val actions = buildList {
add(PlayerActionSpec(stringResource(R.string.player_aspect_ratio_label, aspectRatioLabel), onToggleAspectRatio))
add(PlayerActionSpec(
stringResource(if (isMuted) R.string.player_unmute else R.string.player_mute),
onToggleMute
))
+ add(PlayerActionSpec(
+ stringResource(if (isCastConnected) R.string.player_stop_casting else R.string.player_cast),
+ if (isCastConnected) onStopCasting else onCast
+ ))
add(PlayerActionSpec(stringResource(R.string.player_picture_in_picture), onEnterPictureInPicture))
if (subtitleTrackCount > 0) {
add(PlayerActionSpec(stringResource(R.string.player_subs), onOpenSubtitleTracks))
}
- if (audioTrackCount > 1) {
+ if (audioTrackCount > 0) {
add(PlayerActionSpec(stringResource(R.string.player_audio), onOpenAudioTracks))
}
if (videoQualityCount > 1) {
add(PlayerActionSpec(stringResource(R.string.player_video_quality), onOpenVideoTracks))
}
}
+ var sliderValue by remember(duration, currentPosition) {
+ mutableStateOf(if (duration > 0) currentPosition.toFloat() / duration.toFloat() else 0f)
+ }
+ var isScrubbing by remember { mutableStateOf(false) }
+ val latestSeekCallback by rememberUpdatedState(onSeekToPosition)
+ val latestScrubbingCallback by rememberUpdatedState(onSetScrubbingMode)
+
+ LaunchedEffect(duration, currentPosition, isScrubbing) {
+ if (!isScrubbing) {
+ sliderValue = if (duration > 0) currentPosition.toFloat() / duration.toFloat() else 0f
+ }
+ }
Row(
verticalAlignment = Alignment.CenterVertically,
@@ -745,159 +795,159 @@ private fun PlayerVodInfo(
Spacer(modifier = Modifier.height(14.dp))
- Row(verticalAlignment = Alignment.CenterVertically) {
- var sliderValue by remember(duration, currentPosition) {
- mutableStateOf(
- if (duration > 0) currentPosition.toFloat() / duration.toFloat() else 0f
- )
- }
- var isScrubbing by remember { mutableStateOf(false) }
- val latestSeekCallback by rememberUpdatedState(onSeekToPosition)
- val latestScrubbingCallback by rememberUpdatedState(onSetScrubbingMode)
-
- LaunchedEffect(duration, currentPosition, isScrubbing) {
- if (!isScrubbing) {
- sliderValue = if (duration > 0) {
- currentPosition.toFloat() / duration.toFloat()
- } else {
- 0f
- }
- }
- }
-
- Text(
- text = formatDuration(
- if (isScrubbing && duration > 0) {
- (sliderValue * duration).toLong()
- } else {
- currentPosition
- }
- ),
- style = MaterialTheme.typography.labelMedium,
- color = Color.White
- )
- Slider(
- value = sliderValue,
- onValueChange = { newValue ->
- if (!isScrubbing) {
- isScrubbing = true
- latestScrubbingCallback(true)
- }
- sliderValue = newValue
- },
- onValueChangeFinished = {
- if (duration > 0) {
- latestSeekCallback((sliderValue.coerceIn(0f, 1f) * duration).toLong())
- }
- if (isScrubbing) {
- latestScrubbingCallback(false)
- isScrubbing = false
- }
- },
- modifier = Modifier
- .weight(1f)
- .padding(horizontal = 16.dp),
- enabled = duration > 0,
- colors = SliderDefaults.colors(
- activeTrackColor = Primary,
- inactiveTrackColor = Color.White.copy(alpha = 0.2f)
- )
- )
- Text(
- text = formatDuration(duration),
- style = MaterialTheme.typography.labelMedium,
- color = Color.White
- )
- }
-
- PlayerQuickActionRows(
- primaryActions = actions,
- secondaryActions = emptyList(),
- firstActionFocusRequester = quickActionsFocusRequester,
- primaryActionsUpFocusRequester = quickActionsFocusRequester
- )
-}
-
-@Composable
-private fun PlayerTransportBar(
- isPlaying: Boolean,
- playButtonFocusRequester: FocusRequester,
- quickActionsFocusRequester: FocusRequester,
- onSeekBackward: () -> Unit,
- onSeekForward: () -> Unit,
- onTogglePlayPause: () -> Unit,
- modifier: Modifier = Modifier
-) {
- val playPauseDescription = if (isPlaying) {
- stringResource(R.string.player_pause)
- } else {
- stringResource(R.string.player_play)
- }
Surface(
- modifier = modifier,
- shape = RoundedCornerShape(999.dp),
- colors = SurfaceDefaults.colors(containerColor = Color.Black.copy(alpha = 0.52f))
+ shape = RoundedCornerShape(24.dp),
+ colors = SurfaceDefaults.colors(containerColor = Color.White.copy(alpha = 0.06f))
) {
Row(
- modifier = Modifier.padding(horizontal = 20.dp, vertical = 12.dp),
- horizontalArrangement = Arrangement.spacedBy(24.dp),
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(horizontal = 18.dp, vertical = 16.dp),
+ horizontalArrangement = Arrangement.spacedBy(18.dp),
verticalAlignment = Alignment.CenterVertically
) {
- Text(
- text = stringResource(R.string.player_playback_label),
- style = MaterialTheme.typography.labelMedium,
- color = Color.White.copy(alpha = 0.7f)
- )
- PlayerTransportButton(
- label = "\u23EA",
- contentDescription = stringResource(R.string.player_rewind),
- onClick = onSeekBackward,
- modifier = Modifier.focusProperties {
- down = quickActionsFocusRequester
- }
- )
Surface(
- onClick = onTogglePlayPause,
- shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(50)),
- colors = ClickableSurfaceDefaults.colors(
- containerColor = Primary.copy(alpha = 0.8f),
- focusedContainerColor = Primary
- ),
- modifier = Modifier
- .size(80.dp)
- .focusRequester(playButtonFocusRequester)
- .focusProperties {
- down = quickActionsFocusRequester
- }
- .semantics { contentDescription = playPauseDescription }
+ shape = RoundedCornerShape(999.dp),
+ colors = SurfaceDefaults.colors(containerColor = Color.Black.copy(alpha = 0.24f))
) {
- Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
- if (isPlaying) {
- Text(
- text = "II",
- style = MaterialTheme.typography.headlineMedium,
- color = Color.White
- )
- } else {
- Icon(
- imageVector = Icons.Default.PlayArrow,
- contentDescription = stringResource(R.string.player_play),
- tint = Color.White,
- modifier = Modifier.size(38.dp)
- )
+ Row(
+ modifier = Modifier.padding(horizontal = 10.dp, vertical = 8.dp),
+ horizontalArrangement = Arrangement.spacedBy(10.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ PlayerTransportButton(
+ label = "\u23EA",
+ contentDescription = stringResource(R.string.player_rewind),
+ onClick = onSeekBackward,
+ modifier = Modifier.focusProperties {
+ down = quickActionsFocusRequester
+ }
+ )
+ Surface(
+ onClick = onTogglePlayPause,
+ shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(50)),
+ colors = ClickableSurfaceDefaults.colors(
+ containerColor = Primary.copy(alpha = 0.84f),
+ focusedContainerColor = Primary
+ ),
+ modifier = Modifier
+ .size(72.dp)
+ .focusRequester(playButtonFocusRequester)
+ .focusProperties {
+ down = quickActionsFocusRequester
+ }
+ .semantics { contentDescription = playbackLabel }
+ ) {
+ Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
+ if (isPlaying) {
+ Text(
+ text = "II",
+ style = MaterialTheme.typography.headlineMedium,
+ color = Color.White
+ )
+ } else {
+ Icon(
+ imageVector = Icons.Default.PlayArrow,
+ contentDescription = stringResource(R.string.player_play),
+ tint = Color.White,
+ modifier = Modifier.size(34.dp)
+ )
+ }
+ }
}
+ PlayerTransportButton(
+ label = "\u23E9",
+ contentDescription = stringResource(R.string.player_forward),
+ onClick = onSeekForward,
+ modifier = Modifier.focusProperties {
+ down = quickActionsFocusRequester
+ }
+ )
}
}
- PlayerTransportButton(
- label = "\u23E9",
- contentDescription = stringResource(R.string.player_forward),
- onClick = onSeekForward,
- modifier = Modifier.focusProperties {
- down = quickActionsFocusRequester
+
+ Column(
+ modifier = Modifier.weight(1f),
+ verticalArrangement = Arrangement.spacedBy(10.dp)
+ ) {
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.SpaceBetween,
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Text(
+ text = playbackLabel,
+ style = MaterialTheme.typography.labelLarge,
+ color = Color.White.copy(alpha = 0.78f)
+ )
+ Text(
+ text = title,
+ style = MaterialTheme.typography.labelMedium,
+ color = Color.White.copy(alpha = 0.58f),
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis
+ )
}
- )
+
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ Text(
+ text = formatDuration(
+ if (isScrubbing && duration > 0) {
+ (sliderValue * duration).toLong()
+ } else {
+ currentPosition
+ }
+ ),
+ style = MaterialTheme.typography.labelMedium,
+ color = Color.White
+ )
+ Slider(
+ value = sliderValue,
+ onValueChange = { newValue ->
+ if (!isScrubbing) {
+ isScrubbing = true
+ latestScrubbingCallback(true)
+ }
+ sliderValue = newValue
+ },
+ onValueChangeFinished = {
+ if (duration > 0) {
+ latestSeekCallback((sliderValue.coerceIn(0f, 1f) * duration).toLong())
+ }
+ if (isScrubbing) {
+ latestScrubbingCallback(false)
+ isScrubbing = false
+ }
+ },
+ modifier = Modifier
+ .weight(1f)
+ .padding(horizontal = 16.dp)
+ .focusProperties {
+ down = quickActionsFocusRequester
+ }
+ .semantics { contentDescription = playbackLabel },
+ enabled = duration > 0,
+ colors = SliderDefaults.colors(
+ activeTrackColor = Primary,
+ inactiveTrackColor = Color.White.copy(alpha = 0.2f)
+ )
+ )
+ Text(
+ text = formatDuration(duration),
+ style = MaterialTheme.typography.labelMedium,
+ color = Color.White
+ )
+ }
+ }
}
}
+
+ PlayerQuickActionRows(
+ primaryActions = actions,
+ secondaryActions = emptyList(),
+ firstActionFocusRequester = quickActionsFocusRequester,
+ primaryActionsUpFocusRequester = playButtonFocusRequester
+ )
}
@Composable
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerOverlays.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerOverlays.kt
index 79e668ec..a82a75a3 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerOverlays.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerOverlays.kt
@@ -172,7 +172,19 @@ fun ChannelInfoOverlay(
isPlaying: Boolean,
currentAspectRatio: String,
isDiagnosticsEnabled: Boolean,
- onOpenSplitScreen: () -> Unit = {}
+ onOpenSplitScreen: () -> Unit = {},
+ subtitleTrackCount: Int = 0,
+ audioTrackCount: Int = 0,
+ videoQualityCount: Int = 0,
+ isMuted: Boolean = false,
+ onToggleMute: () -> Unit = {},
+ onOpenSubtitleTracks: () -> Unit = {},
+ onOpenAudioTracks: () -> Unit = {},
+ onOpenVideoTracks: () -> Unit = {},
+ onEnterPictureInPicture: () -> Unit = {},
+ isCastConnected: Boolean = false,
+ onCast: () -> Unit = {},
+ onStopCasting: () -> Unit = {}
) {
val timeFormat = SimpleDateFormat("HH:mm", Locale.getDefault())
@@ -181,25 +193,25 @@ fun ChannelInfoOverlay(
PlayerOverlayPanel(
modifier = Modifier
.fillMaxWidth()
- .padding(horizontal = 56.dp, vertical = 20.dp)
+ .padding(horizontal = 40.dp, vertical = 16.dp)
) {
Column(
modifier = Modifier.fillMaxWidth(),
- verticalArrangement = Arrangement.spacedBy(10.dp)
+ verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Column(
modifier = Modifier.fillMaxWidth(),
- verticalArrangement = Arrangement.spacedBy(6.dp)
+ verticalArrangement = Arrangement.spacedBy(4.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
- horizontalArrangement = Arrangement.spacedBy(10.dp),
+ horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
if (currentChannel != null) {
Box(
modifier = Modifier
- .size(52.dp)
+ .size(44.dp)
.clip(RoundedCornerShape(12.dp))
.border(1.dp, AppColors.Focus.copy(alpha = 0.05f), RoundedCornerShape(12.dp))
) {
@@ -333,107 +345,196 @@ fun ChannelInfoOverlay(
}
}
- Row(
+ LazyRow(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(6.dp),
- verticalAlignment = Alignment.CenterVertically
+ verticalAlignment = Alignment.CenterVertically,
+ contentPadding = PaddingValues(end = 8.dp)
) {
- QuickActionButton(
- icon = stringResource(R.string.player_action_playback),
- label = if (isPlaying) stringResource(R.string.player_pause) else stringResource(R.string.player_play),
- onClick = {
- onOverlayInteracted()
- onTogglePlayPause()
- },
- onInteraction = onOverlayInteracted,
- colors = ClickableSurfaceDefaults.colors(
- containerColor = Primary.copy(alpha = 0.20f),
- focusedContainerColor = Primary,
- pressedContainerColor = Primary.copy(alpha = 0.8f)
- ),
- modifier = Modifier.focusRequester(focusRequester)
- )
- QuickActionButton(
- icon = if (currentRecordingStatus == RecordingStatus.RECORDING) {
- stringResource(R.string.player_stop_recording)
- } else {
- stringResource(R.string.player_record)
- },
- label = if (currentRecordingStatus == RecordingStatus.RECORDING) {
- stringResource(R.string.player_stop_recording)
- } else {
- stringResource(R.string.player_record)
- },
- onClick = {
- onOverlayInteracted()
- if (currentRecordingStatus == RecordingStatus.RECORDING) {
- onStopRecording()
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_playback),
+ label = if (isPlaying) stringResource(R.string.player_pause) else stringResource(R.string.player_play),
+ onClick = {
+ onOverlayInteracted()
+ onTogglePlayPause()
+ },
+ onInteraction = onOverlayInteracted,
+ colors = ClickableSurfaceDefaults.colors(
+ containerColor = Primary.copy(alpha = 0.20f),
+ focusedContainerColor = Primary,
+ pressedContainerColor = Primary.copy(alpha = 0.8f)
+ ),
+ modifier = Modifier.focusRequester(focusRequester)
+ )
+ }
+ item {
+ QuickActionButton(
+ icon = if (currentRecordingStatus == RecordingStatus.RECORDING) {
+ stringResource(R.string.player_stop_recording)
} else {
- onStartRecording()
- }
- },
- onInteraction = onOverlayInteracted
- )
+ stringResource(R.string.player_record)
+ },
+ label = if (currentRecordingStatus == RecordingStatus.RECORDING) {
+ stringResource(R.string.player_stop_recording)
+ } else {
+ stringResource(R.string.player_record)
+ },
+ onClick = {
+ onOverlayInteracted()
+ if (currentRecordingStatus == RecordingStatus.RECORDING) {
+ onStopRecording()
+ } else {
+ onStartRecording()
+ }
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
if (currentChannel?.catchUpSupported == true && currentProgram?.hasArchive == true) {
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_restart_short),
+ label = stringResource(R.string.player_restart),
+ onClick = {
+ onOverlayInteracted()
+ onRestartProgram()
+ onDismiss()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ }
+ item {
QuickActionButton(
- icon = stringResource(R.string.player_action_restart_short),
- label = stringResource(R.string.player_restart),
+ icon = stringResource(R.string.player_action_view),
+ label = currentAspectRatio,
onClick = {
onOverlayInteracted()
- onRestartProgram()
- onDismiss()
+ onToggleAspectRatio()
},
onInteraction = onOverlayInteracted
)
}
- QuickActionButton(
- icon = stringResource(R.string.player_action_view),
- label = currentAspectRatio,
- onClick = {
- onOverlayInteracted()
- onToggleAspectRatio()
- },
- onInteraction = onOverlayInteracted
- )
if (!lastVisitedCategoryName.isNullOrBlank()) {
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_group),
+ label = lastVisitedCategoryName,
+ onClick = {
+ onOverlayInteracted()
+ onOpenLastGroup()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ }
+ item {
QuickActionButton(
- icon = stringResource(R.string.player_action_group),
- label = stringResource(R.string.player_last_group_label, lastVisitedCategoryName),
+ icon = stringResource(R.string.player_action_guide),
+ label = stringResource(R.string.player_epg_short),
onClick = {
onOverlayInteracted()
- onOpenLastGroup()
+ onOpenFullEpg()
},
onInteraction = onOverlayInteracted
)
}
- QuickActionButton(
- icon = stringResource(R.string.player_action_guide),
- label = stringResource(R.string.player_full_epg),
- onClick = {
- onOverlayInteracted()
- onOpenFullEpg()
- },
- onInteraction = onOverlayInteracted
- )
- QuickActionButton(
- icon = stringResource(R.string.player_action_split),
- label = stringResource(R.string.multiview_nav),
- onClick = {
- onOverlayInteracted()
- onDismiss()
- onOpenSplitScreen()
- },
- onInteraction = onOverlayInteracted
- )
- QuickActionButton(
- icon = stringResource(R.string.player_action_diagnostics),
- label = stringResource(R.string.player_stats),
- onClick = {
- onOverlayInteracted()
- onToggleDiagnostics()
- },
- onInteraction = onOverlayInteracted
- )
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_split),
+ label = stringResource(R.string.player_multiview_short),
+ onClick = {
+ onOverlayInteracted()
+ onDismiss()
+ onOpenSplitScreen()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_diagnostics),
+ label = stringResource(R.string.player_stats),
+ onClick = {
+ onOverlayInteracted()
+ onToggleDiagnostics()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_mute),
+ label = if (isMuted) stringResource(R.string.player_unmute) else stringResource(R.string.player_mute),
+ onClick = {
+ onOverlayInteracted()
+ onToggleMute()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_cast),
+ label = if (isCastConnected) stringResource(R.string.player_stop_casting) else stringResource(R.string.player_cast),
+ onClick = {
+ onOverlayInteracted()
+ if (isCastConnected) onStopCasting() else onCast()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_pip),
+ label = stringResource(R.string.player_pip_short),
+ onClick = {
+ onOverlayInteracted()
+ onEnterPictureInPicture()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ if (subtitleTrackCount > 0) {
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_subs),
+ label = stringResource(R.string.player_subs),
+ onClick = {
+ onOverlayInteracted()
+ onOpenSubtitleTracks()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ }
+ if (audioTrackCount > 0) {
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_audio),
+ label = stringResource(R.string.player_audio),
+ onClick = {
+ onOverlayInteracted()
+ onOpenAudioTracks()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ }
+ if (videoQualityCount > 0) {
+ item {
+ QuickActionButton(
+ icon = stringResource(R.string.player_action_quality),
+ label = stringResource(R.string.player_quality_short),
+ onClick = {
+ onOverlayInteracted()
+ onOpenVideoTracks()
+ },
+ onInteraction = onOverlayInteracted
+ )
+ }
+ }
}
}
}
@@ -457,7 +558,7 @@ private fun QuickActionButton(
onClick()
},
modifier = modifier
- .widthIn(min = 92.dp, max = 176.dp)
+ .widthIn(min = 84.dp, max = 138.dp)
.onFocusChanged {
if (it.isFocused) onInteraction()
},
@@ -466,9 +567,9 @@ private fun QuickActionButton(
scale = ClickableSurfaceDefaults.scale(focusedScale = 1.01f)
) {
Column(
- modifier = Modifier.padding(horizontal = 10.dp, vertical = 7.dp),
+ modifier = Modifier.padding(horizontal = 10.dp, vertical = 6.dp),
horizontalAlignment = Alignment.Start,
- verticalArrangement = Arrangement.spacedBy(1.dp)
+ verticalArrangement = Arrangement.spacedBy(0.dp)
) {
AnimatedContent(
targetState = icon,
@@ -479,7 +580,7 @@ private fun QuickActionButton(
) { targetIcon ->
Text(
text = targetIcon.uppercase(Locale.getDefault()),
- style = MaterialTheme.typography.labelSmall,
+ style = MaterialTheme.typography.labelSmall.copy(fontSize = 10.sp),
color = AppColors.BrandStrong,
fontWeight = FontWeight.Bold,
maxLines = 1,
@@ -488,7 +589,7 @@ private fun QuickActionButton(
}
Text(
text = label,
- style = MaterialTheme.typography.labelSmall,
+ style = MaterialTheme.typography.bodySmall.copy(fontSize = 10.sp),
color = AppColors.TextPrimary,
fontWeight = FontWeight.Bold,
maxLines = 1,
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerSystemOverlays.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerSystemOverlays.kt
index 2c5bbadb..3d6af233 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerSystemOverlays.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/overlay/PlayerSystemOverlays.kt
@@ -1,5 +1,6 @@
package com.streamvault.app.ui.screens.player.overlay
+import android.view.KeyEvent
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
@@ -16,18 +17,26 @@ import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
import androidx.tv.material3.ClickableSurfaceDefaults
import androidx.tv.material3.MaterialTheme
import androidx.tv.material3.Surface
import androidx.tv.material3.Text
import com.streamvault.app.R
+import com.streamvault.app.ui.design.requestFocusSafely
import com.streamvault.app.ui.screens.player.PlayerNoticeAction
import com.streamvault.app.ui.screens.player.PlayerNoticeState
import com.streamvault.app.ui.theme.ErrorColor
@@ -179,6 +188,8 @@ fun PlayerTrackSelectionDialog(
) {
if (trackType == null) return
+ val firstItemFocusRequester = remember(trackType) { FocusRequester() }
+
val tracks = when (trackType) {
TrackType.AUDIO -> audioTracks
TrackType.VIDEO -> videoTracks
@@ -190,54 +201,86 @@ fun PlayerTrackSelectionDialog(
TrackType.TEXT -> stringResource(R.string.player_track_subs)
}
- Box(
- modifier = Modifier
- .fillMaxSize()
- .background(Color.Black.copy(alpha = 0.8f))
- .clickable(onClick = onDismiss),
- contentAlignment = Alignment.Center
+ LaunchedEffect(trackType, tracks.firstOrNull()?.id) {
+ firstItemFocusRequester.requestFocusSafely(
+ tag = "PlayerTrackSelectionDialog",
+ target = "First track option"
+ )
+ }
+
+ Dialog(
+ onDismissRequest = onDismiss,
+ properties = DialogProperties(usePlatformDefaultWidth = false)
) {
- Column(
+ Box(
modifier = Modifier
- .widthIn(min = 300.dp, max = 400.dp)
- .background(SurfaceElevated, RoundedCornerShape(12.dp))
- .padding(24.dp)
+ .fillMaxSize()
+ .background(Color.Black.copy(alpha = 0.8f))
+ .clickable(onClick = onDismiss),
+ contentAlignment = Alignment.Center
) {
- Text(
- text = title,
- style = MaterialTheme.typography.titleLarge,
- color = Color.White,
- modifier = Modifier.padding(bottom = 16.dp)
- )
+ Column(
+ modifier = Modifier
+ .widthIn(min = 300.dp, max = 400.dp)
+ .background(SurfaceElevated, RoundedCornerShape(12.dp))
+ .padding(24.dp)
+ .onPreviewKeyEvent { event ->
+ if (event.nativeKeyEvent.action != KeyEvent.ACTION_DOWN) return@onPreviewKeyEvent false
+ when (event.nativeKeyEvent.keyCode) {
+ KeyEvent.KEYCODE_DPAD_UP,
+ KeyEvent.KEYCODE_DPAD_DOWN,
+ KeyEvent.KEYCODE_DPAD_LEFT,
+ KeyEvent.KEYCODE_DPAD_RIGHT,
+ KeyEvent.KEYCODE_DPAD_CENTER,
+ KeyEvent.KEYCODE_ENTER,
+ KeyEvent.KEYCODE_NUMPAD_ENTER,
+ KeyEvent.KEYCODE_BACK -> false
+ else -> true
+ }
+ }
+ ) {
+ Text(
+ text = title,
+ style = MaterialTheme.typography.titleLarge,
+ color = Color.White,
+ modifier = Modifier.padding(bottom = 16.dp)
+ )
+
+ LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ if (trackType == TrackType.TEXT) {
+ item {
+ TrackSelectionItem(
+ name = stringResource(R.string.player_track_off),
+ isSelected = tracks.none { it.isSelected },
+ onClick = {
+ onSelectSubtitle(null)
+ onDismiss()
+ },
+ modifier = Modifier.focusRequester(firstItemFocusRequester)
+ )
+ }
+ }
- LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) {
- if (trackType == TrackType.TEXT) {
- item {
+ items(tracks, key = { it.id }) { track ->
TrackSelectionItem(
- name = stringResource(R.string.player_track_off),
- isSelected = tracks.none { it.isSelected },
+ name = track.name,
+ isSelected = track.isSelected,
onClick = {
- onSelectSubtitle(null)
+ when (trackType) {
+ TrackType.AUDIO -> onSelectAudio(track.id)
+ TrackType.VIDEO -> onSelectVideo(track.id)
+ TrackType.TEXT -> onSelectSubtitle(track.id)
+ }
onDismiss()
+ },
+ modifier = if (trackType != TrackType.TEXT && track == tracks.firstOrNull()) {
+ Modifier.focusRequester(firstItemFocusRequester)
+ } else {
+ Modifier
}
)
}
}
-
- items(tracks, key = { it.id }) { track ->
- TrackSelectionItem(
- name = track.name,
- isSelected = track.isSelected,
- onClick = {
- when (trackType) {
- TrackType.AUDIO -> onSelectAudio(track.id)
- TrackType.VIDEO -> onSelectVideo(track.id)
- TrackType.TEXT -> onSelectSubtitle(track.id)
- }
- onDismiss()
- }
- )
- }
}
}
}
@@ -247,7 +290,8 @@ fun PlayerTrackSelectionDialog(
private fun TrackSelectionItem(
name: String,
isSelected: Boolean,
- onClick: () -> Unit
+ onClick: () -> Unit,
+ modifier: Modifier = Modifier
) {
Surface(
onClick = onClick,
@@ -256,7 +300,7 @@ private fun TrackSelectionItem(
containerColor = if (isSelected) Primary.copy(alpha = 0.2f) else Color.Transparent,
focusedContainerColor = SurfaceHighlight
),
- modifier = Modifier.fillMaxWidth()
+ modifier = modifier.fillMaxWidth()
) {
Row(
modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp),
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt
index e069bc0e..1a357f89 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt
@@ -29,7 +29,7 @@ import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.ui.platform.LocalContext
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/search/SearchScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/search/SearchScreen.kt
index a588d001..7c675447 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/search/SearchScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/search/SearchScreen.kt
@@ -23,8 +23,15 @@ import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.heading
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.selected
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.tv.material3.*
@@ -149,6 +156,14 @@ class SearchViewModel @Inject constructor(
onSearchSubmitted()
}
+ fun submitExternalQuery(query: String) {
+ val normalizedQuery = query.trim()
+ if (normalizedQuery.length < 2) return
+
+ _query.value = normalizedQuery
+ onSearchSubmitted()
+ }
+
fun clearRecentQueries() {
_recentQueries.value = emptyList()
}
@@ -169,7 +184,7 @@ private data class SearchFilterParams(
val level: Int
)
-enum class SearchTab(@StringRes val titleRes: Int) {
+enum class SearchTab(@get:StringRes val titleRes: Int) {
ALL(R.string.search_all),
LIVE(R.string.search_live_tv),
MOVIES(R.string.search_movies),
@@ -193,6 +208,7 @@ data class SearchUiState(
@OptIn(ExperimentalTvMaterial3Api::class)
@Composable
fun SearchScreen(
+ initialQuery: String = "",
onChannelClick: (Channel) -> Unit,
onMovieClick: (Movie) -> Unit,
onSeriesClick: (Series) -> Unit,
@@ -213,11 +229,19 @@ fun SearchScreen(
var pendingMovie by remember { mutableStateOf<Movie?>(null) }
var pendingSeries by remember { mutableStateOf<Series?>(null) }
val scope = rememberCoroutineScope()
+ val selectedStateLabel = stringResource(R.string.a11y_selected)
LaunchedEffect(Unit) {
runCatching { searchFocusRequester.requestFocus() }
}
+ LaunchedEffect(initialQuery) {
+ if (initialQuery.isNotBlank()) {
+ viewModel.submitExternalQuery(initialQuery)
+ focusManager.clearFocus()
+ }
+ }
+
LaunchedEffect(showPinDialog) {
if (!showPinDialog) {
runCatching { searchFocusRequester.requestFocus() }
@@ -271,7 +295,8 @@ fun SearchScreen(
Text(
text = stringResource(R.string.search_title),
style = MaterialTheme.typography.headlineSmall,
- color = TextPrimary
+ color = TextPrimary,
+ modifier = Modifier.semantics { heading() }
)
}
@@ -306,6 +331,12 @@ fun SearchScreen(
FilterChip(
selected = tab == selectedTab,
onClick = { viewModel.onTabSelected(tab) },
+ modifier = Modifier.semantics {
+ selected = tab == selectedTab
+ if (tab == selectedTab) {
+ stateDescription = selectedStateLabel
+ }
+ },
colors = FilterChipDefaults.colors(
selectedContainerColor = Primary,
selectedContentColor = Color.White
@@ -327,7 +358,8 @@ fun SearchScreen(
Text(
text = stringResource(R.string.search_recent_title),
style = MaterialTheme.typography.titleSmall,
- color = OnSurface
+ color = OnSurface,
+ modifier = Modifier.semantics { heading() }
)
TextButton(onClick = { viewModel.clearRecentQueries() }) {
Text(stringResource(R.string.search_clear_history))
@@ -340,12 +372,20 @@ fun SearchScreen(
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
items(recentQueries, key = { it }) { recentQuery ->
+ val recentQueryDescription = stringResource(R.string.a11y_recent_search, recentQuery)
FilterChip(
selected = recentQuery.equals(query, ignoreCase = true),
onClick = {
viewModel.onRecentQuerySelected(recentQuery)
focusManager.clearFocus()
},
+ modifier = Modifier.semantics {
+ contentDescription = recentQueryDescription
+ if (recentQuery.equals(query, ignoreCase = true)) {
+ selected = true
+ stateDescription = selectedStateLabel
+ }
+ },
colors = FilterChipDefaults.colors(
selectedContainerColor = Primary,
selectedContentColor = Color.White
@@ -483,7 +523,9 @@ fun SectionHeader(title: String) {
text = title,
style = MaterialTheme.typography.titleMedium,
color = Primary,
- modifier = Modifier.padding(vertical = 8.dp)
+ modifier = Modifier
+ .padding(vertical = 8.dp)
+ .semantics { heading() }
)
}
@@ -494,6 +536,7 @@ private fun SearchResultsSummaryRow(
selectedTab: SearchTab,
onTabSelected: (SearchTab) -> Unit
) {
+ val selectedStateLabel = stringResource(R.string.a11y_selected)
val summaryChips = listOf(
SearchSummaryChip(SearchTab.ALL, stringResource(R.string.search_all), uiState.totalResults),
SearchSummaryChip(SearchTab.LIVE, stringResource(R.string.search_live_tv), uiState.channels.size),
@@ -501,13 +544,16 @@ private fun SearchResultsSummaryRow(
SearchSummaryChip(SearchTab.SERIES, stringResource(R.string.search_series), uiState.series.size)
)
Column(
- modifier = Modifier.fillMaxWidth(),
+ modifier = Modifier
+ .fillMaxWidth()
+ .semantics { liveRegion = LiveRegionMode.Polite },
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Text(
text = stringResource(R.string.search_results_title, uiState.totalResults),
style = MaterialTheme.typography.titleMedium,
- color = OnSurface
+ color = OnSurface,
+ modifier = Modifier.semantics { heading() }
)
androidx.compose.foundation.lazy.LazyRow(
horizontalArrangement = Arrangement.spacedBy(8.dp)
@@ -516,6 +562,12 @@ private fun SearchResultsSummaryRow(
FilterChip(
selected = chip.tab == selectedTab,
onClick = { onTabSelected(chip.tab) },
+ modifier = Modifier.semantics {
+ selected = chip.tab == selectedTab
+ if (chip.tab == selectedTab) {
+ stateDescription = selectedStateLabel
+ }
+ },
colors = FilterChipDefaults.colors(
selectedContainerColor = Primary,
selectedContentColor = Color.White
@@ -535,7 +587,8 @@ private fun SearchMessageState(
) {
TvEmptyState(
title = title,
- subtitle = subtitle
+ subtitle = subtitle,
+ modifier = Modifier.semantics { liveRegion = LiveRegionMode.Polite }
)
}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt
index 532e1901..4ff68c4f 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt
@@ -33,7 +33,7 @@ import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.Border
import androidx.tv.material3.Button
import androidx.tv.material3.ButtonDefaults
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt
index 11d25eb4..e50ee397 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt
@@ -16,7 +16,7 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.*
import androidx.compose.ui.layout.ContentScale
import coil3.compose.AsyncImage
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt
index 0c5f1b4a..b24d568f 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt
@@ -69,7 +69,7 @@ class SeriesViewModel @Inject constructor(
.filterNotNull()
.flatMapLatest { provider ->
combine(
- favoriteRepository.getAllFavorites(ContentType.SERIES),
+ favoriteRepository.getFavorites(ContentType.SERIES),
getCustomCategories(ContentType.SERIES),
seriesRepository.getCategories(provider.id),
seriesRepository.getCategoryItemCounts(provider.id),
@@ -134,7 +134,7 @@ class SeriesViewModel @Inject constructor(
.filterNotNull()
.flatMapLatest { provider ->
combine(
- favoriteRepository.getAllFavorites(ContentType.SERIES),
+ favoriteRepository.getFavorites(ContentType.SERIES),
getCustomCategories(ContentType.SERIES),
seriesRepository.getCategories(provider.id),
seriesRepository.getCategoryItemCounts(provider.id)
@@ -209,7 +209,7 @@ class SeriesViewModel @Inject constructor(
.filterNotNull()
.flatMapLatest { provider ->
combine(
- favoriteRepository.getAllFavorites(ContentType.SERIES),
+ favoriteRepository.getFavorites(ContentType.SERIES),
playbackHistoryRepository.getRecentlyWatchedByProvider(provider.id, limit = 24),
seriesRepository.getTopRatedPreview(provider.id, PREVIEW_ROW_LIMIT),
seriesRepository.getFreshPreview(provider.id, PREVIEW_ROW_LIMIT)
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt
index c9ecca89..0df762cc 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt
@@ -16,7 +16,7 @@ import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.platform.LocalUriHandler
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.tv.material3.*
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt
index 947cce7f..a97e3ca3 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt
@@ -4,6 +4,7 @@ import android.app.Application
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.streamvault.app.R
+import com.streamvault.app.tvinput.TvInputChannelSyncManager
import com.streamvault.app.ui.model.LiveTvChannelMode
import com.streamvault.data.preferences.PreferencesRepository
import com.streamvault.data.sync.SyncManager
@@ -54,7 +55,8 @@ class SettingsViewModel @Inject constructor(
private val recordingManager: RecordingManager,
private val syncManager: SyncManager,
private val syncMetadataRepository: SyncMetadataRepository,
- private val playbackHistoryRepository: com.streamvault.domain.repository.PlaybackHistoryRepository
+ private val playbackHistoryRepository: com.streamvault.domain.repository.PlaybackHistoryRepository,
+ private val tvInputChannelSyncManager: TvInputChannelSyncManager
) : ViewModel() {
private val appContext = application
@@ -204,9 +206,16 @@ class SettingsViewModel @Inject constructor(
fun clearHistory() {
viewModelScope.launch {
_uiState.update { it.copy(isSyncing = true) }
- playbackHistoryRepository.clearAllHistory()
- preferencesRepository.clearAllRecentData()
- _uiState.update { it.copy(isSyncing = false, userMessage = appContext.getString(R.string.settings_history_cleared)) }
+ when (val result = playbackHistoryRepository.clearAllHistory()) {
+ is Result.Success -> {
+ preferencesRepository.clearAllRecentData()
+ _uiState.update { it.copy(isSyncing = false, userMessage = appContext.getString(R.string.settings_history_cleared)) }
+ }
+ is Result.Error -> {
+ _uiState.update { it.copy(isSyncing = false, userMessage = "Failed to clear history: ${result.message}") }
+ }
+ Result.Loading -> Unit
+ }
}
}
@@ -229,9 +238,12 @@ class SettingsViewModel @Inject constructor(
viewModelScope.launch {
_uiState.update { it.copy(isSyncing = true) }
val result = providerRepository.refreshProviderData(providerId, force = true)
+ if (result !is Result.Error) {
+ tvInputChannelSyncManager.refreshTvInputCatalog()
+ }
val refreshedProvider = providerRepository.getProvider(providerId)
_uiState.update { state ->
- val partialWarnings = (syncManager.syncState.value as? SyncState.Partial)?.warnings.orEmpty()
+ val partialWarnings = (syncManager.currentSyncState(providerId) as? SyncState.Partial)?.warnings.orEmpty()
val warningsMessage = partialWarnings
.take(3)
.joinToString(separator = ", ")
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupScreen.kt
index ab99f6e1..fc47f280 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupScreen.kt
@@ -35,7 +35,7 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.foundation.shape.RoundedCornerShape
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupViewModel.kt
index 48e4fcf0..e7e708ff 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/parental/ParentalControlGroupViewModel.kt
@@ -4,6 +4,7 @@ import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.streamvault.domain.model.Category
+import com.streamvault.domain.model.Result
import com.streamvault.domain.repository.CategoryRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.*
@@ -59,12 +60,20 @@ class ParentalControlGroupViewModel @Inject constructor(
fun toggleCategoryProtection(category: Category) {
viewModelScope.launch {
- categoryRepository.setCategoryProtection(
+ when (val result = categoryRepository.setCategoryProtection(
providerId = providerId,
categoryId = category.id,
type = category.type,
isProtected = !category.isUserProtected
- )
+ )) {
+ is Result.Success -> Unit
+ is Result.Error -> android.util.Log.w(
+ "ParentalControlGroupVM",
+ "Failed to update protection for ${category.name}: ${result.message}",
+ result.exception
+ )
+ is Result.Loading -> Unit
+ }
}
}
}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/welcome/WelcomeScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/welcome/WelcomeScreen.kt
index 13751c76..79e0983a 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/welcome/WelcomeScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/welcome/WelcomeScreen.kt
@@ -22,7 +22,7 @@ import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.compose.material3.CircularProgressIndicator
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 7b2a37b3..3b9f7c6b 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -26,6 +26,7 @@
<!-- Home -->
<string name="home_incorrect_pin">Incorrect PIN</string>
+ <string name="home_loading_categories">Loading categories...</string>
<string name="home_loading_channels">Loading channels...</string>
<string name="home_categories_title">Categories</string>
<string name="home_search_categories">Search categories...</string>
@@ -389,6 +390,12 @@
<string name="saved_preset_home_shelf_global_title">Home Favorites</string>
<string name="saved_preset_home_shelf_global_subtitle">Live favorites that are eligible for the Home dashboard</string>
<string name="saved_preset_watch_next">Watch Next</string>
+ <string name="tv_channel_continue_watching_title">Continue Watching</string>
+ <string name="tv_channel_continue_watching_description">Resume titles you started recently</string>
+ <string name="tv_channel_top_movies_title">Top Movies</string>
+ <string name="tv_channel_top_movies_description">Popular picks from %1$s</string>
+ <string name="tv_channel_fresh_series_title">Fresh Series</string>
+ <string name="tv_channel_fresh_series_description">Recently updated series from %1$s</string>
<string name="saved_preset_live_recall">Live Recall</string>
<string name="saved_preset_custom_groups">Custom Groups</string>
<string name="saved_group_manage_title">Manage Custom Groups</string>
@@ -444,6 +451,13 @@
<string name="search_hint">Search...</string>
<string name="search_recent_title">Recent Searches</string>
<string name="search_clear_history">Clear</string>
+ <string name="a11y_selected">Selected</string>
+ <string name="a11y_recent_search">Recent search %1$s</string>
+ <string name="a11y_locked">Locked</string>
+ <string name="a11y_favorite">Favorite</string>
+ <string name="a11y_catch_up_available">Catch-up available</string>
+ <string name="a11y_now_playing">Now playing %1$s</string>
+ <string name="a11y_channel_with_number">Channel %1$d, %2$s</string>
<!-- Provider Setup -->
<string name="setup_title_streamvault">StreamVault</string>
@@ -520,10 +534,20 @@
<string name="player_recording_missing_context">Recording needs a valid live channel context.</string>
<string name="player_subs">Subs</string>
<string name="player_audio">Audio</string>
+ <string name="player_action_mute">Mute</string>
+ <string name="player_action_cast">Cast</string>
+ <string name="player_action_pip">PiP</string>
+ <string name="player_action_quality">Quality</string>
<string name="player_mute">Mute</string>
<string name="player_muted_badge">Muted</string>
+ <string name="player_cast">Cast</string>
+ <string name="player_stop_casting">Stop Casting</string>
<string name="player_unmute">Unmute</string>
<string name="player_picture_in_picture">Picture in picture</string>
+ <string name="player_pip_short">PiP</string>
+ <string name="player_epg_short">EPG</string>
+ <string name="player_multiview_short">Multiview</string>
+ <string name="player_quality_short">Quality</string>
<string name="player_resume_title">Resume Playback</string>
<string name="player_resume_desc">Do you want to resume %1$s from where you left off?</string>
<string name="player_resume_start_over">Start Over</string>
diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml
index d5ab37e5..f35e69c9 100644
--- a/app/src/main/res/values/themes.xml
+++ b/app/src/main/res/values/themes.xml
@@ -6,4 +6,10 @@
<item name="android:windowIsTranslucent">false</item>
<item name="android:windowBackground">@android:color/black</item>
</style>
+
+ <style name="Theme.StreamVault.CastChooser" parent="Theme.AppCompat.Dialog">
+ <item name="android:windowBackground">@android:color/transparent</item>
+ <item name="android:windowIsTranslucent">true</item>
+ <item name="android:windowCloseOnTouchOutside">true</item>
+ </style>
</resources>
diff --git a/app/src/main/res/xml/searchable.xml b/app/src/main/res/xml/searchable.xml
new file mode 100644
index 00000000..b0241ff4
--- /dev/null
+++ b/app/src/main/res/xml/searchable.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<searchable xmlns:android="http://schemas.android.com/apk/res/android"
+ android:label="@string/search_title"
+ android:hint="@string/search_hint"
+ android:includeInGlobalSearch="true"
+ android:queryAfterZeroResults="true"
+ android:voiceSearchMode="showVoiceSearchButton|launchRecognizer" />
\ No newline at end of file
diff --git a/app/src/main/res/xml/tv_input_service.xml b/app/src/main/res/xml/tv_input_service.xml
new file mode 100644
index 00000000..9d40162c
--- /dev/null
+++ b/app/src/main/res/xml/tv_input_service.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<tv-input xmlns:android="http://schemas.android.com/apk/res/android"
+ android:canRecord="false"
+ android:label="@string/app_name" />
\ No newline at end of file
diff --git a/data/build.gradle.kts b/data/build.gradle.kts
index 6de9b823..6bab5619 100644
--- a/data/build.gradle.kts
+++ b/data/build.gradle.kts
@@ -66,6 +66,7 @@ dependencies {
// DataStore
implementation(libs.datastore.preferences)
+ implementation(libs.security.crypto)
// Core
implementation(libs.core.ktx)
diff --git a/data/schemas/com.streamvault.data.local.StreamVaultDatabase/14.json b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/14.json
new file mode 100644
index 00000000..fcf63b08
--- /dev/null
+++ b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/14.json
@@ -0,0 +1,1591 @@
+{
+ "formatVersion": 1,
+ "database": {
+ "version": 14,
+ "identityHash": "e52bbc6b4a9d34c27fa0fee885457260",
+ "entities": [
+ {
+ "tableName": "providers",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `type` TEXT NOT NULL, `server_url` TEXT NOT NULL, `username` TEXT NOT NULL, `password` TEXT NOT NULL, `m3u_url` TEXT NOT NULL, `epg_url` TEXT NOT NULL, `is_active` INTEGER NOT NULL, `max_connections` INTEGER NOT NULL, `expiration_date` INTEGER, `status` TEXT NOT NULL, `last_synced_at` INTEGER NOT NULL, `created_at` INTEGER NOT NULL)",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "type",
+ "columnName": "type",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "serverUrl",
+ "columnName": "server_url",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "username",
+ "columnName": "username",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "password",
+ "columnName": "password",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "m3uUrl",
+ "columnName": "m3u_url",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "epgUrl",
+ "columnName": "epg_url",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isActive",
+ "columnName": "is_active",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "maxConnections",
+ "columnName": "max_connections",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "expirationDate",
+ "columnName": "expiration_date",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "status",
+ "columnName": "status",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastSyncedAt",
+ "columnName": "last_synced_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "createdAt",
+ "columnName": "created_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_providers_server_url_username",
+ "unique": true,
+ "columnNames": [
+ "server_url",
+ "username"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_providers_server_url_username` ON `${TABLE_NAME}` (`server_url`, `username`)"
+ }
+ ]
+ },
+ {
+ "tableName": "channels",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "streamId",
+ "columnName": "stream_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "logoUrl",
+ "columnName": "logo_url",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "groupTitle",
+ "columnName": "group_title",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "categoryId",
+ "columnName": "category_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "categoryName",
+ "columnName": "category_name",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "streamUrl",
+ "columnName": "stream_url",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "epgChannelId",
+ "columnName": "epg_channel_id",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "number",
+ "columnName": "number",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "catchUpSupported",
+ "columnName": "catch_up_supported",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "catchUpDays",
+ "columnName": "catch_up_days",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "catchUpSource",
+ "columnName": "catchUpSource",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isAdult",
+ "columnName": "is_adult",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isUserProtected",
+ "columnName": "is_user_protected",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "logicalGroupId",
+ "columnName": "logical_group_id",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "errorCount",
+ "columnName": "error_count",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_channels_provider_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id` ON `${TABLE_NAME}` (`provider_id`)"
+ },
+ {
+ "name": "index_channels_provider_id_category_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id",
+ "category_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"
+ },
+ {
+ "name": "index_channels_provider_id_stream_id",
+ "unique": true,
+ "columnNames": [
+ "provider_id",
+ "stream_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channels_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"
+ },
+ {
+ "name": "index_channels_logical_group_id",
+ "unique": false,
+ "columnNames": [
+ "logical_group_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_logical_group_id` ON `${TABLE_NAME}` (`logical_group_id`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "providers",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "provider_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "channel_preferences",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `channel_id` INTEGER NOT NULL, `aspect_ratio` TEXT, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`channel_id`) REFERENCES `channels`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "channelId",
+ "columnName": "channel_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "aspectRatio",
+ "columnName": "aspect_ratio",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "updatedAt",
+ "columnName": "updated_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_channel_preferences_channel_id",
+ "unique": true,
+ "columnNames": [
+ "channel_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_preferences_channel_id` ON `${TABLE_NAME}` (`channel_id`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "channels",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "channel_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "channels_fts",
+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`channels`)",
+ "fields": [
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": false,
+ "columnNames": []
+ },
+ "ftsVersion": "FTS4",
+ "ftsOptions": {
+ "tokenizer": "simple",
+ "tokenizerArgs": [],
+ "contentTable": "channels",
+ "languageIdColumnName": "",
+ "matchInfo": "FTS4",
+ "notIndexedColumns": [],
+ "prefixSizes": [],
+ "preferredOrder": "ASC"
+ },
+ "contentSyncTriggers": [
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_UPDATE BEFORE UPDATE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_DELETE BEFORE DELETE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_UPDATE AFTER UPDATE ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_INSERT AFTER INSERT ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"
+ ]
+ },
+ {
+ "tableName": "movies",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "streamId",
+ "columnName": "stream_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "posterUrl",
+ "columnName": "poster_url",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "backdropUrl",
+ "columnName": "backdrop_url",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "categoryId",
+ "columnName": "category_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "categoryName",
+ "columnName": "category_name",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "streamUrl",
+ "columnName": "stream_url",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "containerExtension",
+ "columnName": "container_extension",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "plot",
+ "columnName": "plot",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "cast",
+ "columnName": "cast",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "director",
+ "columnName": "director",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "genre",
+ "columnName": "genre",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "releaseDate",
+ "columnName": "release_date",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "duration",
+ "columnName": "duration",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "durationSeconds",
+ "columnName": "duration_seconds",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "rating",
+ "columnName": "rating",
+ "affinity": "REAL",
+ "notNull": true
+ },
+ {
+ "fieldPath": "year",
+ "columnName": "year",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "tmdbId",
+ "columnName": "tmdb_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "youtubeTrailer",
+ "columnName": "youtube_trailer",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "watchProgress",
+ "columnName": "watch_progress",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastWatchedAt",
+ "columnName": "last_watched_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isAdult",
+ "columnName": "is_adult",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isUserProtected",
+ "columnName": "is_user_protected",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_movies_provider_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id` ON `${TABLE_NAME}` (`provider_id`)"
+ },
+ {
+ "name": "index_movies_provider_id_category_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id",
+ "category_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"
+ },
+ {
+ "name": "index_movies_provider_id_stream_id",
+ "unique": true,
+ "columnNames": [
+ "provider_id",
+ "stream_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_movies_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "providers",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "provider_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "movies_fts",
+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`movies`)",
+ "fields": [
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": false,
+ "columnNames": []
+ },
+ "ftsVersion": "FTS4",
+ "ftsOptions": {
+ "tokenizer": "simple",
+ "tokenizerArgs": [],
+ "contentTable": "movies",
+ "languageIdColumnName": "",
+ "matchInfo": "FTS4",
+ "notIndexedColumns": [],
+ "prefixSizes": [],
+ "preferredOrder": "ASC"
+ },
+ "contentSyncTriggers": [
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_UPDATE BEFORE UPDATE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_DELETE BEFORE DELETE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_UPDATE AFTER UPDATE ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_INSERT AFTER INSERT ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"
+ ]
+ },
+ {
+ "tableName": "series",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `series_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "seriesId",
+ "columnName": "series_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "posterUrl",
+ "columnName": "poster_url",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "backdropUrl",
+ "columnName": "backdrop_url",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "categoryId",
+ "columnName": "category_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "categoryName",
+ "columnName": "category_name",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "plot",
+ "columnName": "plot",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "cast",
+ "columnName": "cast",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "director",
+ "columnName": "director",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "genre",
+ "columnName": "genre",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "releaseDate",
+ "columnName": "release_date",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "rating",
+ "columnName": "rating",
+ "affinity": "REAL",
+ "notNull": true
+ },
+ {
+ "fieldPath": "tmdbId",
+ "columnName": "tmdb_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "youtubeTrailer",
+ "columnName": "youtube_trailer",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "episodeRunTime",
+ "columnName": "episode_run_time",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "lastModified",
+ "columnName": "last_modified",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isAdult",
+ "columnName": "is_adult",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isUserProtected",
+ "columnName": "is_user_protected",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_series_provider_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id` ON `${TABLE_NAME}` (`provider_id`)"
+ },
+ {
+ "name": "index_series_provider_id_category_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id",
+ "category_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"
+ },
+ {
+ "name": "index_series_provider_id_series_id",
+ "unique": true,
+ "columnNames": [
+ "provider_id",
+ "series_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_series_provider_id_series_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "providers",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "provider_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "series_fts",
+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`series`)",
+ "fields": [
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": false,
+ "columnNames": []
+ },
+ "ftsVersion": "FTS4",
+ "ftsOptions": {
+ "tokenizer": "simple",
+ "tokenizerArgs": [],
+ "contentTable": "series",
+ "languageIdColumnName": "",
+ "matchInfo": "FTS4",
+ "notIndexedColumns": [],
+ "prefixSizes": [],
+ "preferredOrder": "ASC"
+ },
+ "contentSyncTriggers": [
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_UPDATE BEFORE UPDATE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_DELETE BEFORE DELETE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_UPDATE AFTER UPDATE ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",
+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_INSERT AFTER INSERT ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"
+ ]
+ },
+ {
+ "tableName": "episodes",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `episode_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `episode_number` INTEGER NOT NULL, `season_number` INTEGER NOT NULL, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `cover_url` TEXT, `plot` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `release_date` TEXT, `series_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`series_id`) REFERENCES `series`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "episodeId",
+ "columnName": "episode_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "title",
+ "columnName": "title",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "episodeNumber",
+ "columnName": "episode_number",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "seasonNumber",
+ "columnName": "season_number",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "streamUrl",
+ "columnName": "stream_url",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "containerExtension",
+ "columnName": "container_extension",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "coverUrl",
+ "columnName": "cover_url",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "plot",
+ "columnName": "plot",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "duration",
+ "columnName": "duration",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "durationSeconds",
+ "columnName": "duration_seconds",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "rating",
+ "columnName": "rating",
+ "affinity": "REAL",
+ "notNull": true
+ },
+ {
+ "fieldPath": "releaseDate",
+ "columnName": "release_date",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "seriesId",
+ "columnName": "series_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "watchProgress",
+ "columnName": "watch_progress",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastWatchedAt",
+ "columnName": "last_watched_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isAdult",
+ "columnName": "is_adult",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isUserProtected",
+ "columnName": "is_user_protected",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_episodes_series_id",
+ "unique": false,
+ "columnNames": [
+ "series_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_series_id` ON `${TABLE_NAME}` (`series_id`)"
+ },
+ {
+ "name": "index_episodes_provider_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_provider_id` ON `${TABLE_NAME}` (`provider_id`)"
+ },
+ {
+ "name": "index_episodes_provider_id_episode_id",
+ "unique": true,
+ "columnNames": [
+ "provider_id",
+ "episode_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_episodes_provider_id_episode_id` ON `${TABLE_NAME}` (`provider_id`, `episode_id`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "providers",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "provider_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ },
+ {
+ "table": "series",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "series_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "categories",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "categoryId",
+ "columnName": "category_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "parentId",
+ "columnName": "parent_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "type",
+ "columnName": "type",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isAdult",
+ "columnName": "is_adult",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "isUserProtected",
+ "columnName": "is_user_protected",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_categories_provider_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id` ON `${TABLE_NAME}` (`provider_id`)"
+ },
+ {
+ "name": "index_categories_provider_id_type",
+ "unique": false,
+ "columnNames": [
+ "provider_id",
+ "type"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"
+ },
+ {
+ "name": "index_categories_provider_id_category_id_type",
+ "unique": true,
+ "columnNames": [
+ "provider_id",
+ "category_id",
+ "type"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_categories_provider_id_category_id_type` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `type`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "providers",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "provider_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "programs",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `title` TEXT NOT NULL, `description` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `lang` TEXT NOT NULL, `has_archive` INTEGER NOT NULL)",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "channelId",
+ "columnName": "channel_id",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "title",
+ "columnName": "title",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "description",
+ "columnName": "description",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "startTime",
+ "columnName": "start_time",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "endTime",
+ "columnName": "end_time",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lang",
+ "columnName": "lang",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "hasArchive",
+ "columnName": "has_archive",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_programs_provider_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"
+ },
+ {
+ "name": "index_programs_provider_id_channel_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id",
+ "channel_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id` ON `${TABLE_NAME}` (`provider_id`, `channel_id`)"
+ },
+ {
+ "name": "index_programs_provider_id_start_time_end_time",
+ "unique": false,
+ "columnNames": [
+ "provider_id",
+ "start_time",
+ "end_time"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `start_time`, `end_time`)"
+ },
+ {
+ "name": "index_programs_start_time",
+ "unique": false,
+ "columnNames": [
+ "start_time"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_start_time` ON `${TABLE_NAME}` (`start_time`)"
+ },
+ {
+ "name": "index_programs_provider_id_channel_id_start_time",
+ "unique": false,
+ "columnNames": [
+ "provider_id",
+ "channel_id",
+ "start_time"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`)"
+ },
+ {
+ "name": "index_programs_provider_id_channel_id_start_time_end_time",
+ "unique": true,
+ "columnNames": [
+ "provider_id",
+ "channel_id",
+ "start_time",
+ "end_time"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`, `end_time`)"
+ }
+ ]
+ },
+ {
+ "tableName": "favorites",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `position` INTEGER NOT NULL, `group_id` INTEGER, `added_at` INTEGER NOT NULL, FOREIGN KEY(`group_id`) REFERENCES `virtual_groups`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "contentId",
+ "columnName": "content_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "contentType",
+ "columnName": "content_type",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "position",
+ "columnName": "position",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "groupId",
+ "columnName": "group_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "addedAt",
+ "columnName": "added_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_favorites_content_id_content_type_group_id",
+ "unique": true,
+ "columnNames": [
+ "content_id",
+ "content_type",
+ "group_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_favorites_content_id_content_type_group_id` ON `${TABLE_NAME}` (`content_id`, `content_type`, `group_id`)"
+ },
+ {
+ "name": "index_favorites_content_type_group_id",
+ "unique": false,
+ "columnNames": [
+ "content_type",
+ "group_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_content_type_group_id` ON `${TABLE_NAME}` (`content_type`, `group_id`)"
+ },
+ {
+ "name": "index_favorites_group_id_position",
+ "unique": false,
+ "columnNames": [
+ "group_id",
+ "position"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_group_id_position` ON `${TABLE_NAME}` (`group_id`, `position`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "virtual_groups",
+ "onDelete": "SET NULL",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "group_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "virtual_groups",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `icon_emoji` TEXT, `position` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `content_type` TEXT NOT NULL)",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "name",
+ "columnName": "name",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "iconEmoji",
+ "columnName": "icon_emoji",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "position",
+ "columnName": "position",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "createdAt",
+ "columnName": "created_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "contentType",
+ "columnName": "content_type",
+ "affinity": "TEXT",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_virtual_groups_position",
+ "unique": false,
+ "columnNames": [
+ "position"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_position` ON `${TABLE_NAME}` (`position`)"
+ },
+ {
+ "name": "index_virtual_groups_content_type",
+ "unique": false,
+ "columnNames": [
+ "content_type"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_content_type` ON `${TABLE_NAME}` (`content_type`)"
+ }
+ ]
+ },
+ {
+ "tableName": "playback_history",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `poster_url` TEXT, `stream_url` TEXT NOT NULL, `resume_position_ms` INTEGER NOT NULL, `total_duration_ms` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "id",
+ "columnName": "id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "contentId",
+ "columnName": "content_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "contentType",
+ "columnName": "content_type",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "title",
+ "columnName": "title",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "posterUrl",
+ "columnName": "poster_url",
+ "affinity": "TEXT"
+ },
+ {
+ "fieldPath": "streamUrl",
+ "columnName": "stream_url",
+ "affinity": "TEXT",
+ "notNull": true
+ },
+ {
+ "fieldPath": "resumePositionMs",
+ "columnName": "resume_position_ms",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "totalDurationMs",
+ "columnName": "total_duration_ms",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastWatchedAt",
+ "columnName": "last_watched_at",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "watchCount",
+ "columnName": "watch_count",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "seriesId",
+ "columnName": "series_id",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "seasonNumber",
+ "columnName": "season_number",
+ "affinity": "INTEGER"
+ },
+ {
+ "fieldPath": "episodeNumber",
+ "columnName": "episode_number",
+ "affinity": "INTEGER"
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": true,
+ "columnNames": [
+ "id"
+ ]
+ },
+ "indices": [
+ {
+ "name": "index_playback_history_content_id_content_type_provider_id",
+ "unique": true,
+ "columnNames": [
+ "content_id",
+ "content_type",
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_history_content_id_content_type_provider_id` ON `${TABLE_NAME}` (`content_id`, `content_type`, `provider_id`)"
+ },
+ {
+ "name": "index_playback_history_last_watched_at",
+ "unique": false,
+ "columnNames": [
+ "last_watched_at"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_last_watched_at` ON `${TABLE_NAME}` (`last_watched_at`)"
+ },
+ {
+ "name": "index_playback_history_provider_id",
+ "unique": false,
+ "columnNames": [
+ "provider_id"
+ ],
+ "orders": [],
+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"
+ }
+ ],
+ "foreignKeys": [
+ {
+ "table": "providers",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "provider_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ },
+ {
+ "tableName": "sync_metadata",
+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `last_live_sync` INTEGER NOT NULL, `last_movie_sync` INTEGER NOT NULL, `last_series_sync` INTEGER NOT NULL, `last_epg_sync` INTEGER NOT NULL, `live_count` INTEGER NOT NULL, `movie_count` INTEGER NOT NULL, `series_count` INTEGER NOT NULL, `epg_count` INTEGER NOT NULL, `last_sync_status` TEXT NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+ "fields": [
+ {
+ "fieldPath": "providerId",
+ "columnName": "provider_id",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastLiveSync",
+ "columnName": "last_live_sync",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastMovieSync",
+ "columnName": "last_movie_sync",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastSeriesSync",
+ "columnName": "last_series_sync",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastEpgSync",
+ "columnName": "last_epg_sync",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "liveCount",
+ "columnName": "live_count",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "movieCount",
+ "columnName": "movie_count",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "seriesCount",
+ "columnName": "series_count",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "epgCount",
+ "columnName": "epg_count",
+ "affinity": "INTEGER",
+ "notNull": true
+ },
+ {
+ "fieldPath": "lastSyncStatus",
+ "columnName": "last_sync_status",
+ "affinity": "TEXT",
+ "notNull": true
+ }
+ ],
+ "primaryKey": {
+ "autoGenerate": false,
+ "columnNames": [
+ "provider_id"
+ ]
+ },
+ "foreignKeys": [
+ {
+ "table": "providers",
+ "onDelete": "CASCADE",
+ "onUpdate": "NO ACTION",
+ "columns": [
+ "provider_id"
+ ],
+ "referencedColumns": [
+ "id"
+ ]
+ }
+ ]
+ }
+ ],
+ "setupQueries": [
+ "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+ "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'e52bbc6b4a9d34c27fa0fee885457260')"
+ ]
+ }
+}
\ No newline at end of file
diff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt
index fcc1685c..961ab376 100644
--- a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt
+++ b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt
@@ -26,7 +26,7 @@ import com.streamvault.data.local.entity.*
PlaybackHistoryEntity::class,
SyncMetadataEntity::class
],
- version = 13,
+ version = 14,
exportSchema = true // ← was false; schema JSON now tracked in version control
)
@TypeConverters(RoomEnumConverters::class)
@@ -929,5 +929,23 @@ abstract class StreamVaultDatabase : RoomDatabase() {
)
}
}
+
+ /**
+ * Migration 13 β†’ 14: add targeted secondary indexes for broad EPG windows,
+ * provider/type category filtering, and virtual group content type lookups.
+ */
+ val MIGRATION_13_14 = object : Migration(13, 14) {
+ override fun migrate(database: SupportSQLiteDatabase) {
+ database.execSQL(
+ "CREATE INDEX IF NOT EXISTS index_programs_provider_id_start_time_end_time ON programs(provider_id, start_time, end_time)"
+ )
+ database.execSQL(
+ "CREATE INDEX IF NOT EXISTS index_categories_provider_id_type ON categories(provider_id, type)"
+ )
+ database.execSQL(
+ "CREATE INDEX IF NOT EXISTS index_virtual_groups_content_type ON virtual_groups(content_type)"
+ )
+ }
+ }
}
}
\ No newline at end of file
diff --git a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt b/data/src/main/java/com/streamvault/data/local/entity/Entities.kt
index cfb779c9..6b712b03 100644
--- a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt
+++ b/data/src/main/java/com/streamvault/data/local/entity/Entities.kt
@@ -241,6 +241,7 @@ data class EpisodeEntity(
)],
indices = [
Index(value = ["provider_id"]),
+ Index(value = ["provider_id", "type"]),
Index(value = ["provider_id", "category_id", "type"], unique = true)
]
)
@@ -261,6 +262,7 @@ data class CategoryEntity(
indices = [
Index(value = ["provider_id"]),
Index(value = ["provider_id", "channel_id"]),
+ Index(value = ["provider_id", "start_time", "end_time"]),
Index(value = ["start_time"]),
Index(value = ["provider_id", "channel_id", "start_time"]),
Index(value = ["provider_id", "channel_id", "start_time", "end_time"], unique = true)
@@ -305,7 +307,10 @@ data class FavoriteEntity(
@Entity(
tableName = "virtual_groups",
- indices = [Index(value = ["position"])]
+ indices = [
+ Index(value = ["position"]),
+ Index(value = ["content_type"])
+ ]
)
data class VirtualGroupEntity(
@PrimaryKey(autoGenerate = true)
diff --git a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
index c778a7f8..3b37f0f1 100644
--- a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
+++ b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
@@ -1,6 +1,9 @@
package com.streamvault.data.preferences
import android.content.Context
+import android.content.SharedPreferences
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.booleanPreferencesKey
@@ -11,6 +14,8 @@ import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import com.streamvault.data.local.dao.ChannelPreferenceDao
import com.streamvault.data.local.entity.ChannelPreferenceEntity
+import com.streamvault.domain.manager.ParentalControlSessionState
+import com.streamvault.domain.manager.ParentalControlSessionStore
import java.security.SecureRandom
import javax.crypto.SecretKeyFactory
import javax.crypto.spec.PBEKeySpec
@@ -31,11 +36,13 @@ private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(na
class PreferencesRepository @Inject constructor(
@ApplicationContext private val context: Context,
private val channelPreferenceDao: ChannelPreferenceDao
-) {
+) : ParentalControlSessionStore {
companion object {
private const val PIN_SALT_BYTES = 16
private const val PIN_HASH_ITERATIONS = 120_000
private const val PIN_HASH_KEY_BITS = 256
+ private const val PIN_MAX_ATTEMPTS = 5
+ private const val PIN_LOCKOUT_DURATION_MS = 15 * 60 * 1000L
private val secureRandom = SecureRandom()
}
@@ -62,6 +69,27 @@ class PreferencesRepository @Inject constructor(
val PLAYER_MUTED = booleanPreferencesKey("player_muted")
}
+ private object ParentalSessionKeys {
+ const val FILE_NAME = "parental_control_session"
+ const val UNLOCK_ENTRIES = "unlock_entries"
+ const val UNLOCK_TIMEOUT_MS = "unlock_timeout_ms"
+ const val PIN_FAILED_ATTEMPTS = "pin_failed_attempts"
+ const val PIN_LOCKOUT_UNTIL_MS = "pin_lockout_until_ms"
+ }
+
+ private val parentalSessionPreferences: SharedPreferences by lazy {
+ val masterKey = MasterKey.Builder(context)
+ .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+ .build()
+ EncryptedSharedPreferences.create(
+ context,
+ ParentalSessionKeys.FILE_NAME,
+ masterKey,
+ EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+ EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+ )
+ }
+
val lastActiveProviderId: Flow<Long?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_ACTIVE_PROVIDER_ID]
}
@@ -127,6 +155,10 @@ class PreferencesRepository @Inject constructor(
}
suspend fun verifyParentalPin(pin: String): Boolean {
+ if (isPinLockedOut()) {
+ return false
+ }
+
val preferences = context.dataStore.data.first()
val storedHash = preferences[PreferencesKeys.PARENTAL_PIN_HASH]
@@ -135,7 +167,9 @@ class PreferencesRepository @Inject constructor(
if (!storedHash.isNullOrBlank() && !storedSaltBase64.isNullOrBlank()) {
val salt = runCatching { java.util.Base64.getDecoder().decode(storedSaltBase64) }.getOrNull()
?: return false
- return hashPin(pin, salt) == storedHash
+ val valid = hashPin(pin, salt) == storedHash
+ updatePinAttemptState(valid)
+ return valid
}
val legacyPin = preferences[PreferencesKeys.LEGACY_PARENTAL_PIN]
@@ -146,9 +180,36 @@ class PreferencesRepository @Inject constructor(
setParentalPin(pin)
}
+ updatePinAttemptState(valid)
+
return valid
}
+ override fun readSessionState(): ParentalControlSessionState {
+ val timeoutMs = parentalSessionPreferences.getLong(
+ ParentalSessionKeys.UNLOCK_TIMEOUT_MS,
+ ParentalControlSessionState.DEFAULT_UNLOCK_TIMEOUT_MS
+ )
+ return ParentalControlSessionState(
+ unlockedCategoryExpirationsByProvider = decodeUnlockEntries(
+ parentalSessionPreferences.getString(ParentalSessionKeys.UNLOCK_ENTRIES, null)
+ ),
+ unlockTimeoutMs = timeoutMs
+ )
+ }
+
+ override fun writeSessionState(state: ParentalControlSessionState) {
+ parentalSessionPreferences.edit().apply {
+ putLong(ParentalSessionKeys.UNLOCK_TIMEOUT_MS, state.unlockTimeoutMs)
+ val encodedUnlocks = encodeUnlockEntries(state.unlockedCategoryExpirationsByProvider)
+ if (encodedUnlocks.isBlank()) {
+ remove(ParentalSessionKeys.UNLOCK_ENTRIES)
+ } else {
+ putString(ParentalSessionKeys.UNLOCK_ENTRIES, encodedUnlocks)
+ }
+ }.apply()
+ }
+
suspend fun clearDefaultViewMode() {
context.dataStore.edit { preferences ->
preferences.remove(PreferencesKeys.DEFAULT_VIEW_MODE)
@@ -344,6 +405,67 @@ class PreferencesRepository @Inject constructor(
return java.util.Base64.getEncoder().encodeToString(secret.encoded)
}
+ private fun isPinLockedOut(nowMs: Long = System.currentTimeMillis()): Boolean {
+ val lockoutUntilMs = parentalSessionPreferences.getLong(ParentalSessionKeys.PIN_LOCKOUT_UNTIL_MS, 0L)
+ if (lockoutUntilMs <= nowMs) {
+ if (lockoutUntilMs != 0L || parentalSessionPreferences.getInt(ParentalSessionKeys.PIN_FAILED_ATTEMPTS, 0) != 0) {
+ parentalSessionPreferences.edit()
+ .remove(ParentalSessionKeys.PIN_LOCKOUT_UNTIL_MS)
+ .remove(ParentalSessionKeys.PIN_FAILED_ATTEMPTS)
+ .apply()
+ }
+ return false
+ }
+ return true
+ }
+
+ private fun updatePinAttemptState(valid: Boolean, nowMs: Long = System.currentTimeMillis()) {
+ val editor = parentalSessionPreferences.edit()
+ if (valid) {
+ editor.remove(ParentalSessionKeys.PIN_FAILED_ATTEMPTS)
+ editor.remove(ParentalSessionKeys.PIN_LOCKOUT_UNTIL_MS)
+ editor.apply()
+ return
+ }
+
+ val failedAttempts = parentalSessionPreferences.getInt(ParentalSessionKeys.PIN_FAILED_ATTEMPTS, 0) + 1
+ if (failedAttempts >= PIN_MAX_ATTEMPTS) {
+ editor.remove(ParentalSessionKeys.PIN_FAILED_ATTEMPTS)
+ editor.putLong(ParentalSessionKeys.PIN_LOCKOUT_UNTIL_MS, nowMs + PIN_LOCKOUT_DURATION_MS)
+ } else {
+ editor.putInt(ParentalSessionKeys.PIN_FAILED_ATTEMPTS, failedAttempts)
+ }
+ editor.apply()
+ }
+
+ private fun encodeUnlockEntries(entries: Map<Long, Map<Long, Long>>): String {
+ return entries.entries
+ .sortedBy { it.key }
+ .flatMap { (providerId, categories) ->
+ categories.entries
+ .sortedBy { it.key }
+ .map { (categoryId, expiresAtMs) -> "$providerId:$categoryId:$expiresAtMs" }
+ }
+ .joinToString(",")
+ }
+
+ private fun decodeUnlockEntries(encoded: String?): Map<Long, Map<Long, Long>> {
+ return encoded
+ .orEmpty()
+ .split(',')
+ .asSequence()
+ .mapNotNull { token ->
+ val parts = token.split(':')
+ if (parts.size != 3) return@mapNotNull null
+ val providerId = parts[0].toLongOrNull() ?: return@mapNotNull null
+ val categoryId = parts[1].toLongOrNull() ?: return@mapNotNull null
+ val expiresAtMs = parts[2].toLongOrNull() ?: return@mapNotNull null
+ Triple(providerId, categoryId, expiresAtMs)
+ }
+ .groupBy({ it.first }, { it.second to it.third })
+ .mapValues { (_, categoryEntries) -> categoryEntries.associate { (categoryId, expiresAtMs) -> categoryId to expiresAtMs } }
+ }
+
private fun hasStoredParentalPin(preferences: Preferences): Boolean {
val storedHash = preferences[PreferencesKeys.PARENTAL_PIN_HASH]
val storedSaltBase64 = preferences[PreferencesKeys.PARENTAL_PIN_SALT]
diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/OkHttpXtreamApiService.kt b/data/src/main/java/com/streamvault/data/remote/xtream/OkHttpXtreamApiService.kt
index 56aad724..61447bc7 100644
--- a/data/src/main/java/com/streamvault/data/remote/xtream/OkHttpXtreamApiService.kt
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/OkHttpXtreamApiService.kt
@@ -11,6 +11,7 @@ import java.io.IOException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
+import kotlinx.serialization.SerializationException
import okhttp3.OkHttpClient
import okhttp3.Request
@@ -46,13 +47,28 @@ class OkHttpXtreamApiService(
.url(endpoint)
.get()
.build()
- client.newCall(request).execute().use { response ->
- if (!response.isSuccessful) {
- throw IOException("HTTP ${response.code}")
+ try {
+ client.newCall(request).execute().use { response ->
+ if (!response.isSuccessful) {
+ val message = "HTTP ${response.code}"
+ when (response.code) {
+ 401, 403 -> throw XtreamAuthenticationException(response.code, message)
+ in 500..599, 429 -> throw XtreamNetworkException(message)
+ else -> throw XtreamRequestException(response.code, message)
+ }
+ }
+ val body = response.body?.string()?.takeIf { it.isNotBlank() }
+ ?: throw XtreamParsingException("Empty response body")
+ try {
+ json.decodeFromString<T>(body)
+ } catch (e: SerializationException) {
+ throw XtreamParsingException("Server returned malformed data", e)
+ }
}
- val body = response.body?.string()?.takeIf { it.isNotBlank() }
- ?: throw IOException("Empty response body")
- json.decodeFromString<T>(body)
+ } catch (e: XtreamApiException) {
+ throw e
+ } catch (e: IOException) {
+ throw XtreamNetworkException(e.message ?: "Network request failed", e)
}
}
}
\ No newline at end of file
diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamApiExceptions.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamApiExceptions.kt
new file mode 100644
index 00000000..b4341533
--- /dev/null
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamApiExceptions.kt
@@ -0,0 +1,21 @@
+package com.streamvault.data.remote.xtream
+
+import java.io.IOException
+
+sealed class XtreamApiException(message: String, cause: Throwable? = null) : Exception(message, cause)
+
+class XtreamNetworkException(message: String, cause: Throwable? = null) : IOException(message, cause)
+
+class XtreamAuthenticationException(
+ val statusCode: Int,
+ message: String,
+ cause: Throwable? = null
+) : XtreamApiException(message, cause)
+
+class XtreamParsingException(message: String, cause: Throwable? = null) : XtreamApiException(message, cause)
+
+class XtreamRequestException(
+ val statusCode: Int,
+ message: String,
+ cause: Throwable? = null
+) : XtreamApiException(message, cause)
\ No newline at end of file
diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamErrorFormatter.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamErrorFormatter.kt
index de51217f..509f2fe2 100644
--- a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamErrorFormatter.kt
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamErrorFormatter.kt
@@ -1,14 +1,18 @@
package com.streamvault.data.remote.xtream
+import com.streamvault.data.security.CredentialDecryptionException
import java.security.cert.CertificateException
import javax.net.ssl.SSLPeerUnverifiedException
internal object XtreamErrorFormatter {
fun message(prefix: String, throwable: Throwable): String {
- return if (throwable.isCertificateTrustFailure()) {
- "$prefix: Server TLS certificate is not trusted by this device. Verify the HTTPS URL or ask the provider for a valid certificate."
- } else {
- "$prefix: ${throwable.message ?: "Unexpected network error"}"
+ return when {
+ throwable is CredentialDecryptionException -> "$prefix: ${throwable.message}"
+ throwable.isCertificateTrustFailure() -> "$prefix: Server TLS certificate is not trusted by this device. Verify the HTTPS URL or ask the provider for a valid certificate."
+ throwable is XtreamAuthenticationException -> "$prefix: Authentication failed. Please check your username, password, and server URL."
+ throwable is XtreamParsingException -> "$prefix: Server returned malformed or unsupported data."
+ throwable is XtreamRequestException -> "$prefix: Request failed with HTTP ${throwable.statusCode}."
+ else -> "$prefix: ${throwable.message ?: "Unexpected network error"}"
}
}
diff --git a/data/src/main/java/com/streamvault/data/repository/CategoryRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/CategoryRepositoryImpl.kt
index 0121198f..3e77d8a0 100644
--- a/data/src/main/java/com/streamvault/data/repository/CategoryRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/CategoryRepositoryImpl.kt
@@ -5,6 +5,7 @@ import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.data.mapper.toDomain
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.Result
import com.streamvault.domain.repository.CategoryRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.combine
@@ -37,13 +38,18 @@ class CategoryRepositoryImpl @Inject constructor(
categoryId: Long,
type: ContentType,
isProtected: Boolean
- ) = transactionRunner.inTransaction {
- categoryDao.updateProtectionStatus(providerId, categoryId, type.name, isProtected)
- when (type) {
- ContentType.LIVE -> channelDao.updateProtectionStatus(providerId, categoryId, isProtected)
- ContentType.MOVIE -> movieDao.updateProtectionStatus(providerId, categoryId, isProtected)
- ContentType.SERIES -> seriesDao.updateProtectionStatus(providerId, categoryId, isProtected)
- ContentType.SERIES_EPISODE -> Unit
+ ): Result<Unit> = try {
+ transactionRunner.inTransaction {
+ categoryDao.updateProtectionStatus(providerId, categoryId, type.name, isProtected)
+ when (type) {
+ ContentType.LIVE -> channelDao.updateProtectionStatus(providerId, categoryId, isProtected)
+ ContentType.MOVIE -> movieDao.updateProtectionStatus(providerId, categoryId, isProtected)
+ ContentType.SERIES -> seriesDao.updateProtectionStatus(providerId, categoryId, isProtected)
+ ContentType.SERIES_EPISODE -> Unit
+ }
}
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to update category protection", e)
}
}
diff --git a/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt
index 8d277818..fcebdab9 100644
--- a/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt
@@ -9,6 +9,7 @@ import com.streamvault.domain.model.Category
import com.streamvault.domain.model.Channel
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.Result
+import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.repository.ChannelRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
@@ -29,6 +30,13 @@ class ChannelRepositoryImpl @Inject constructor(
private val xtreamStreamUrlResolver: XtreamStreamUrlResolver
) : ChannelRepository {
+ private data class ChannelGroupAccumulator(
+ var primary: ChannelEntity,
+ val alternatives: MutableList<ChannelEntity> = mutableListOf()
+ )
+
+ private val channelPriorityComparator = compareBy<ChannelEntity>({ it.errorCount }, { it.name.length })
+
override fun getChannels(providerId: Long): Flow<List<Channel>> =
combine(
channelDao.getByProvider(providerId),
@@ -170,16 +178,18 @@ class ChannelRepositoryImpl @Inject constructor(
override suspend fun getChannel(channelId: Long): Channel? =
channelDao.getById(channelId)?.toDomain()
- @Deprecated("Use getStreamInfo() instead", ReplaceWith("getStreamInfo(channel)"))
- override suspend fun getStreamUrl(channel: Channel): Result<String> =
+ override suspend fun getStreamInfo(channel: Channel): Result<StreamInfo> = try {
xtreamStreamUrlResolver.resolve(
url = channel.streamUrl,
fallbackProviderId = channel.providerId,
fallbackStreamId = channel.streamId,
fallbackContentType = ContentType.LIVE
)?.let { resolvedUrl ->
- Result.success(resolvedUrl)
+ Result.success(StreamInfo(url = resolvedUrl, title = channel.name))
} ?: Result.error("No stream URL available for channel: ${channel.name}")
+ } catch (e: Exception) {
+ Result.error(e.message ?: "Failed to resolve stream URL for channel: ${channel.name}", e)
+ }
override suspend fun refreshChannels(providerId: Long): Result<Unit> {
// Refresh is handled by ProviderRepository.refreshProviderData
@@ -189,26 +199,43 @@ class ChannelRepositoryImpl @Inject constructor(
override fun getChannelsByIds(ids: List<Long>): Flow<List<Channel>> =
channelDao.getByIds(ids).map { entities -> entities.map { it.toDomain() } }
- override suspend fun incrementChannelErrorCount(channelId: Long) {
+ override suspend fun incrementChannelErrorCount(channelId: Long): Result<Unit> = try {
channelDao.incrementErrorCount(channelId)
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to increment channel error count", e)
}
- override suspend fun resetChannelErrorCount(channelId: Long) {
+ override suspend fun resetChannelErrorCount(channelId: Long): Result<Unit> = try {
channelDao.resetErrorCount(channelId)
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to reset channel error count", e)
}
private fun groupAndMapChannels(entities: List<ChannelEntity>, unlockedCats: Set<Long>): List<Channel> {
- return entities.groupBy { channelGroupKey(it) }.values.map { group ->
- // Sort group to pick the primary channel based on reliability and name length
- val sortedGroup = group.sortedWith(compareBy({ it.errorCount }, { it.name.length }))
- val primaryEntity = sortedGroup.first()
- val alternativeStreams = sortedGroup.drop(1).map { it.streamUrl }
-
- val domain = primaryEntity.toDomain().copy(
- alternativeStreams = alternativeStreams
- )
-
- // If category is unlocked, mark channel as NOT protected/ADULT for this session
+ val grouped = LinkedHashMap<String, ChannelGroupAccumulator>()
+ entities.forEach { entity ->
+ val key = channelGroupKey(entity)
+ val existing = grouped[key]
+ if (existing == null) {
+ grouped[key] = ChannelGroupAccumulator(primary = entity)
+ } else if (channelPriorityComparator.compare(entity, existing.primary) < 0) {
+ existing.alternatives += existing.primary
+ existing.primary = entity
+ } else {
+ existing.alternatives += entity
+ }
+ }
+
+ return grouped.values.map { group ->
+ val primaryEntity = group.primary
+ val alternativeStreams = group.alternatives
+ .sortedWith(channelPriorityComparator)
+ .map { it.streamUrl }
+
+ val domain = primaryEntity.toDomain().copy(alternativeStreams = alternativeStreams)
+
if (primaryEntity.categoryId != null && unlockedCats.contains(primaryEntity.categoryId)) {
domain.copy(isUserProtected = false, isAdult = false)
} else {
@@ -233,11 +260,15 @@ class ChannelRepositoryImpl @Inject constructor(
}
private fun groupPrimaryChannelEntities(entities: List<ChannelEntity>): List<ChannelEntity> {
- return entities.groupBy { channelGroupKey(it) }
- .values
- .map { group ->
- group.minWith(compareBy<ChannelEntity> { it.errorCount }.thenBy { it.name.length })
+ val primaries = LinkedHashMap<String, ChannelEntity>()
+ entities.forEach { entity ->
+ val key = channelGroupKey(entity)
+ val current = primaries[key]
+ if (current == null || channelPriorityComparator.compare(entity, current) < 0) {
+ primaries[key] = entity
}
+ }
+ return primaries.values.toList()
}
private fun channelGroupKey(entity: ChannelEntity): String =
diff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
index 3f927ba5..da8e03f8 100644
--- a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
@@ -11,6 +11,7 @@ import com.streamvault.domain.model.LibraryBrowseQuery
import com.streamvault.domain.model.Movie
import com.streamvault.domain.model.PagedResult
import com.streamvault.domain.model.Result
+import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.repository.MovieRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.combine
@@ -196,8 +197,7 @@ class MovieRepositoryImpl @Inject constructor(
return if (movie != null) Result.success(movie) else Result.error("Movie not found")
}
- @Deprecated("Use getStreamInfo() instead", ReplaceWith("getStreamInfo(movie)"))
- override suspend fun getStreamUrl(movie: Movie): Result<String> =
+ override suspend fun getStreamInfo(movie: Movie): Result<StreamInfo> = try {
xtreamStreamUrlResolver.resolve(
url = movie.streamUrl,
fallbackProviderId = movie.providerId,
@@ -205,13 +205,19 @@ class MovieRepositoryImpl @Inject constructor(
fallbackContentType = ContentType.MOVIE,
fallbackContainerExtension = movie.containerExtension
)?.let { resolvedUrl ->
- Result.success(resolvedUrl)
+ Result.success(StreamInfo(url = resolvedUrl, title = movie.name))
} ?: Result.error("No stream URL available for movie: ${movie.name}")
+ } catch (e: Exception) {
+ Result.error(e.message ?: "Failed to resolve stream URL for movie: ${movie.name}", e)
+ }
override suspend fun refreshMovies(providerId: Long): Result<Unit> =
Result.success(Unit) // Handled by ProviderRepository
- override suspend fun updateWatchProgress(movieId: Long, progress: Long) {
+ override suspend fun updateWatchProgress(movieId: Long, progress: Long): Result<Unit> = try {
movieDao.updateWatchProgress(movieId, progress)
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to update movie watch progress", e)
}
}
diff --git a/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt
index 3d1be991..c316686a 100644
--- a/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt
@@ -5,6 +5,7 @@ import com.streamvault.data.mapper.toDomain
import com.streamvault.data.mapper.toEntity
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.Result
import com.streamvault.domain.repository.PlaybackHistoryRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
@@ -32,44 +33,65 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(
return dao.get(contentId, contentType.name, providerId)?.toDomain()
}
- override suspend fun recordPlayback(history: PlaybackHistory) {
- if (preferencesRepository.isIncognitoMode.first()) return
+ override suspend fun recordPlayback(history: PlaybackHistory): Result<Unit> {
+ return try {
+ if (preferencesRepository.isIncognitoMode.first()) {
+ return Result.success(Unit)
+ }
- val existing = dao.get(history.contentId, history.contentType.name, history.providerId)
- val updatedHistory = history.copy(
- streamUrl = XtreamUrlFactory.sanitizePersistedStreamUrl(history.streamUrl, history.providerId),
- resumePositionMs = history.resumePositionMs.takeIf { it > 0L } ?: existing?.resumePositionMs ?: 0L,
- totalDurationMs = history.totalDurationMs.takeIf { it > 0L } ?: existing?.totalDurationMs ?: 0L,
- watchCount = (existing?.watchCount ?: 0) + 1,
- lastWatchedAt = System.currentTimeMillis()
- )
- dao.insertOrUpdate(updatedHistory.toEntity())
+ val existing = dao.get(history.contentId, history.contentType.name, history.providerId)
+ val updatedHistory = history.copy(
+ streamUrl = XtreamUrlFactory.sanitizePersistedStreamUrl(history.streamUrl, history.providerId),
+ resumePositionMs = history.resumePositionMs.takeIf { it > 0L } ?: existing?.resumePositionMs ?: 0L,
+ totalDurationMs = history.totalDurationMs.takeIf { it > 0L } ?: existing?.totalDurationMs ?: 0L,
+ watchCount = (existing?.watchCount ?: 0) + 1,
+ lastWatchedAt = System.currentTimeMillis()
+ )
+ dao.insertOrUpdate(updatedHistory.toEntity())
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to record playback history", e)
+ }
}
- override suspend fun updateResumePosition(history: PlaybackHistory) {
- if (preferencesRepository.isIncognitoMode.first()) return
+ override suspend fun updateResumePosition(history: PlaybackHistory): Result<Unit> {
+ return try {
+ if (preferencesRepository.isIncognitoMode.first()) {
+ return Result.success(Unit)
+ }
- val existing = dao.get(history.contentId, history.contentType.name, history.providerId)
+ val existing = dao.get(history.contentId, history.contentType.name, history.providerId)
- // Resume ticks should not increment watch count on every update.
- // Keep existing count for ongoing sessions; initialize to 1 on first save.
- val updatedHistory = history.copy(
- streamUrl = XtreamUrlFactory.sanitizePersistedStreamUrl(history.streamUrl, history.providerId),
- watchCount = existing?.watchCount ?: 1,
- lastWatchedAt = System.currentTimeMillis()
- )
- dao.insertOrUpdate(updatedHistory.toEntity())
+ val updatedHistory = history.copy(
+ streamUrl = XtreamUrlFactory.sanitizePersistedStreamUrl(history.streamUrl, history.providerId),
+ watchCount = existing?.watchCount ?: 1,
+ lastWatchedAt = System.currentTimeMillis()
+ )
+ dao.insertOrUpdate(updatedHistory.toEntity())
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to update playback resume position", e)
+ }
}
- override suspend fun removeFromHistory(contentId: Long, contentType: ContentType, providerId: Long) {
+ override suspend fun removeFromHistory(contentId: Long, contentType: ContentType, providerId: Long): Result<Unit> = try {
dao.delete(contentId, contentType.name, providerId)
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to remove playback history item", e)
}
- override suspend fun clearAllHistory() {
+ override suspend fun clearAllHistory(): Result<Unit> = try {
dao.deleteAll()
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to clear playback history", e)
}
- override suspend fun clearHistoryForProvider(providerId: Long) {
+ override suspend fun clearHistoryForProvider(providerId: Long): Result<Unit> = try {
dao.deleteByProvider(providerId)
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to clear provider playback history", e)
}
}
diff --git a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
index 8bfa64ad..336a89ba 100644
--- a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
@@ -6,6 +6,7 @@ import com.streamvault.data.mapper.*
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamProvider
import com.streamvault.data.security.CredentialCrypto
+import com.streamvault.data.security.CredentialDecryptionException
import com.streamvault.data.sync.SyncManager
import com.streamvault.data.util.ProviderInputSanitizer
import com.streamvault.data.util.UrlSecurityPolicy
@@ -90,9 +91,13 @@ class ProviderRepositoryImpl @Inject constructor(
} else {
providerDao.getByUrlAndUser(normalizedServerUrl, normalizedUsername)
}
- val effectivePassword = password.takeIf { it.isNotBlank() }
- ?: existingProvider?.password?.let(CredentialCrypto::decryptIfNeeded)
- ?: ""
+ val effectivePassword = try {
+ password.takeIf { it.isNotBlank() }
+ ?: existingProvider?.password?.let(CredentialCrypto::decryptIfNeeded)
+ ?: ""
+ } catch (e: CredentialDecryptionException) {
+ return Result.error(e.message ?: CredentialDecryptionException.MESSAGE, e)
+ }
val provider = createXtreamProvider(0, normalizedServerUrl, normalizedUsername, effectivePassword)
return when (val authResult = provider.authenticate()) {
is Result.Success -> {
@@ -121,7 +126,7 @@ class ProviderRepositoryImpl @Inject constructor(
when (val syncResult = syncManager.sync(providerData.id, force = false, onProgress = onProgress)) {
is Result.Success -> {
- val finalStatus = if (syncManager.syncState.value is SyncState.Partial) {
+ val finalStatus = if (syncManager.currentSyncState(providerData.id) is SyncState.Partial) {
ProviderStatus.PARTIAL
} else {
ProviderStatus.ACTIVE
@@ -201,7 +206,7 @@ class ProviderRepositoryImpl @Inject constructor(
when (val syncResult = syncManager.sync(providerData.id, force = false, onProgress = onProgress)) {
is Result.Success -> {
- val finalStatus = if (syncManager.syncState.value is SyncState.Partial) {
+ val finalStatus = if (syncManager.currentSyncState(providerData.id) is SyncState.Partial) {
ProviderStatus.PARTIAL
} else {
ProviderStatus.ACTIVE
@@ -236,7 +241,7 @@ class ProviderRepositoryImpl @Inject constructor(
): Result<Unit> {
return when (val syncResult = syncManager.sync(providerId, force = force, onProgress = onProgress)) {
is Result.Success -> {
- val finalStatus = if (syncManager.syncState.value is SyncState.Partial) {
+ val finalStatus = if (syncManager.currentSyncState(providerId) is SyncState.Partial) {
ProviderStatus.PARTIAL
} else {
ProviderStatus.ACTIVE
diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
index cd0602a1..5feb488c 100644
--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
@@ -222,7 +222,11 @@ class SeriesRepositoryImpl @Inject constructor(
return Result.success(buildSeriesWithPersistedEpisodes(seriesEntity))
}
- val xtreamProvider = getOrCreateXtreamProvider(providerId, provider)
+ val xtreamProvider = try {
+ getOrCreateXtreamProvider(providerId, provider)
+ } catch (e: Exception) {
+ return Result.error(e.message ?: "Failed to access provider credentials", e)
+ }
return when (val remoteResult = xtreamProvider.getSeriesInfo(seriesEntity.seriesId)) {
is Result.Success -> {
@@ -323,8 +327,7 @@ class SeriesRepositoryImpl @Inject constructor(
}
}
- @Deprecated("Use getEpisodeStreamInfo() instead", ReplaceWith("getEpisodeStreamInfo(episode)"))
- override suspend fun getEpisodeStreamUrl(episode: Episode): Result<String> =
+ override suspend fun getEpisodeStreamInfo(episode: Episode): Result<StreamInfo> = try {
xtreamStreamUrlResolver.resolve(
url = episode.streamUrl,
fallbackProviderId = episode.providerId,
@@ -332,14 +335,20 @@ class SeriesRepositoryImpl @Inject constructor(
fallbackContentType = ContentType.SERIES_EPISODE,
fallbackContainerExtension = episode.containerExtension
)?.let { resolvedUrl ->
- Result.success(resolvedUrl)
+ Result.success(StreamInfo(url = resolvedUrl, title = episode.title))
} ?: Result.error("No stream URL available for episode: ${episode.title}")
+ } catch (e: Exception) {
+ Result.error(e.message ?: "Failed to resolve stream URL for episode: ${episode.title}", e)
+ }
override suspend fun refreshSeries(providerId: Long): Result<Unit> =
Result.success(Unit) // Handled by ProviderRepository
- override suspend fun updateEpisodeWatchProgress(episodeId: Long, progress: Long) {
+ override suspend fun updateEpisodeWatchProgress(episodeId: Long, progress: Long): Result<Unit> = try {
episodeDao.updateWatchProgress(episodeId, progress)
+ Result.success(Unit)
+ } catch (e: Exception) {
+ Result.error("Failed to update episode watch progress", e)
}
private suspend fun buildSeriesWithPersistedEpisodes(seriesEntity: SeriesEntity): Series {
@@ -359,21 +368,23 @@ class SeriesRepositoryImpl @Inject constructor(
}
private fun getOrCreateXtreamProvider(providerId: Long, provider: ProviderEntity): XtreamProvider {
- val decryptedPassword = CredentialCrypto.decryptIfNeeded(provider.password)
- val signature = listOf(provider.serverUrl, provider.username, decryptedPassword).joinToString("\u0000")
- val cached = xtreamProviderCache[providerId]
- if (cached != null && cached.signature == signature) {
- return cached.provider
- }
-
- return XtreamProvider(
- providerId = providerId,
- api = xtreamApiService,
- serverUrl = provider.serverUrl,
- username = provider.username,
- password = decryptedPassword
- ).also { xtreamProvider ->
- xtreamProviderCache[providerId] = CachedXtreamProvider(signature, xtreamProvider)
- }
+ val signature = listOf(provider.serverUrl, provider.username, provider.password).joinToString("\u0000")
+ return xtreamProviderCache.compute(providerId) { _, cached ->
+ if (cached != null && cached.signature == signature) {
+ cached
+ } else {
+ val decryptedPassword = CredentialCrypto.decryptIfNeeded(provider.password)
+ CachedXtreamProvider(
+ signature = signature,
+ provider = XtreamProvider(
+ providerId = providerId,
+ api = xtreamApiService,
+ serverUrl = provider.serverUrl,
+ username = provider.username,
+ password = decryptedPassword
+ )
+ )
+ }
+ }!!.provider
}
}
diff --git a/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt b/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt
index 70b40e1b..c90a4827 100644
--- a/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt
+++ b/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt
@@ -46,7 +46,9 @@ object CredentialCrypto {
return try {
val payload = value.removePrefix(PREFIX)
val bytes = java.util.Base64.getDecoder().decode(payload)
- if (bytes.size <= IV_SIZE_BYTES) return value
+ if (bytes.size <= IV_SIZE_BYTES) {
+ throw CredentialDecryptionException(cause = IllegalArgumentException("Encrypted credential payload is truncated"))
+ }
val iv = bytes.copyOfRange(0, IV_SIZE_BYTES)
val ciphertext = bytes.copyOfRange(IV_SIZE_BYTES, bytes.size)
@@ -59,11 +61,8 @@ object CredentialCrypto {
)
String(cipher.doFinal(ciphertext), Charsets.UTF_8)
} catch (e: Exception) {
- // Decryption failed (e.g. key invalidated after device reset).
- // Return empty string β€” the caller will surface an auth failure rather than
- // silently sending a garbled ciphertext blob as the password.
Log.e(TAG, "Keystore decryption failed. Stored credential is unreadable.", e)
- ""
+ throw CredentialDecryptionException(cause = e)
}
}
diff --git a/data/src/main/java/com/streamvault/data/security/CredentialDecryptionException.kt b/data/src/main/java/com/streamvault/data/security/CredentialDecryptionException.kt
new file mode 100644
index 00000000..f4655cde
--- /dev/null
+++ b/data/src/main/java/com/streamvault/data/security/CredentialDecryptionException.kt
@@ -0,0 +1,10 @@
+package com.streamvault.data.security
+
+class CredentialDecryptionException(
+ message: String = MESSAGE,
+ cause: Throwable? = null
+) : IllegalStateException(message, cause) {
+ companion object {
+ const val MESSAGE = "Stored credentials are no longer readable. Please re-enter your provider credentials."
+ }
+}
\ No newline at end of file
diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
index 27887676..4560042b 100644
--- a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
+++ b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
@@ -12,6 +12,10 @@ import com.streamvault.data.local.entity.MovieEntity
import com.streamvault.data.mapper.toDomain
import com.streamvault.data.mapper.toEntity
import com.streamvault.data.parser.M3uParser
+import com.streamvault.data.remote.xtream.XtreamAuthenticationException
+import com.streamvault.data.remote.xtream.XtreamNetworkException
+import com.streamvault.data.remote.xtream.XtreamParsingException
+import com.streamvault.data.remote.xtream.XtreamRequestException
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamProvider
import com.streamvault.data.remote.xtream.XtreamUrlFactory
@@ -29,10 +33,15 @@ import com.streamvault.domain.repository.EpgRepository
import com.streamvault.domain.repository.SyncMetadataRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.update
import kotlinx.coroutines.withContext
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
@@ -122,40 +131,54 @@ class SyncManager @Inject constructor(
private val _syncState = MutableStateFlow<SyncState>(SyncState.Idle)
val syncState: StateFlow<SyncState> = _syncState.asStateFlow()
+ private val _syncStatesByProvider = MutableStateFlow<Map<Long, SyncState>>(emptyMap())
+ val syncStatesByProvider: StateFlow<Map<Long, SyncState>> = _syncStatesByProvider.asStateFlow()
+ private val syncMutex = Mutex()
+
+ fun syncStateForProvider(providerId: Long): Flow<SyncState> =
+ syncStatesByProvider.map { states -> states[providerId] ?: SyncState.Idle }
+
+ fun currentSyncState(providerId: Long): SyncState =
+ _syncStatesByProvider.value[providerId] ?: SyncState.Idle
suspend fun sync(
providerId: Long,
force: Boolean = false,
onProgress: ((String) -> Unit)? = null
- ): com.streamvault.domain.model.Result<Unit> {
+ ): com.streamvault.domain.model.Result<Unit> = syncMutex.withLock {
val providerEntity = providerDao.getById(providerId)
- ?: return com.streamvault.domain.model.Result.error("Provider $providerId not found")
+ ?: return@withLock com.streamvault.domain.model.Result.error("Provider $providerId not found")
val provider = providerEntity
.copy(password = CredentialCrypto.decryptIfNeeded(providerEntity.password))
.toDomain()
- _syncState.value = SyncState.Syncing("Starting...")
+ publishSyncState(providerId, SyncState.Syncing("Starting..."))
- return try {
+ try {
val outcome = when (provider.type) {
ProviderType.XTREAM_CODES -> syncXtream(provider, force, onProgress)
ProviderType.M3U -> syncM3u(provider, force, onProgress)
}
providerDao.updateSyncTime(providerId, System.currentTimeMillis())
- _syncState.value = if (outcome.partial) {
+ publishSyncState(providerId, if (outcome.partial) {
SyncState.Partial("Sync completed with warnings", outcome.warnings)
} else {
SyncState.Success()
- }
+ })
com.streamvault.domain.model.Result.success(Unit)
} catch (e: Exception) {
Log.e(TAG, "Sync failed for provider $providerId: ${redactUrlForLogs(e.message)}")
- _syncState.value = SyncState.Error(e.message ?: "Unknown error", e)
+ publishSyncState(providerId, SyncState.Error(e.message ?: "Unknown error", e))
com.streamvault.domain.model.Result.error(e.message ?: "Sync failed", e)
}
}
- fun resetState() {
+ fun resetState(providerId: Long? = null) {
+ if (providerId == null) {
+ _syncStatesByProvider.value = emptyMap()
+ } else {
+ _syncStatesByProvider.update { states -> states - providerId }
+ }
_syncState.value = SyncState.Idle
}
@@ -163,25 +186,25 @@ class SyncManager @Inject constructor(
providerId: Long,
section: SyncRepairSection,
onProgress: ((String) -> Unit)? = null
- ): com.streamvault.domain.model.Result<Unit> {
+ ): com.streamvault.domain.model.Result<Unit> = syncMutex.withLock {
val providerEntity = providerDao.getById(providerId)
- ?: return com.streamvault.domain.model.Result.error("Provider $providerId not found")
+ ?: return@withLock com.streamvault.domain.model.Result.error("Provider $providerId not found")
val provider = providerEntity
.copy(password = CredentialCrypto.decryptIfNeeded(providerEntity.password))
.toDomain()
- return try {
+ try {
when (section) {
SyncRepairSection.EPG -> syncEpgOnly(provider, onProgress)
SyncRepairSection.MOVIES -> syncMoviesOnly(provider, onProgress)
SyncRepairSection.SERIES -> syncSeriesOnly(provider, onProgress)
}
- _syncState.value = SyncState.Success()
+ publishSyncState(providerId, SyncState.Success())
com.streamvault.domain.model.Result.success(Unit)
} catch (e: Exception) {
Log.e(TAG, "Section retry failed for provider $providerId [$section]: ${redactUrlForLogs(e.message)}")
- _syncState.value = SyncState.Error(e.message ?: "Retry failed", e)
+ publishSyncState(providerId, SyncState.Error(e.message ?: "Retry failed", e))
com.streamvault.domain.model.Result.error(e.message ?: "Retry failed", e)
}
}
@@ -195,7 +218,7 @@ class SyncManager @Inject constructor(
UrlSecurityPolicy.validateXtreamServerUrl(provider.serverUrl)?.let { message ->
throw IllegalStateException(message)
}
- progress(onProgress, "Connecting to server...")
+ progress(provider.id, onProgress, "Connecting to server...")
val api = XtreamProvider(
providerId = provider.id,
api = xtreamApiService,
@@ -208,7 +231,7 @@ class SyncManager @Inject constructor(
val now = System.currentTimeMillis()
if (force || ContentCachePolicy.shouldRefresh(metadata.lastLiveSync, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {
- progress(onProgress, "Downloading Live TV...")
+ progress(provider.id, onProgress, "Downloading Live TV...")
val cats = retryTransient { api.getLiveCategories().getOrThrow("Live categories") }
categoryDao.replaceAll(provider.id, "LIVE", cats.map { it.toEntity(provider.id) })
@@ -220,7 +243,7 @@ class SyncManager @Inject constructor(
}
if (force || ContentCachePolicy.shouldRefresh(metadata.lastMovieSync, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {
- progress(onProgress, "Downloading Movies...")
+ progress(provider.id, onProgress, "Downloading Movies...")
val catsResult = runCatching { retryTransient { api.getVodCategories().getOrThrow("VOD categories") } }
catsResult.getOrNull()?.let {
categoryDao.replaceAll(provider.id, "MOVIE", it.map { category -> category.toEntity(provider.id) })
@@ -235,7 +258,7 @@ class SyncManager @Inject constructor(
}
if (force || ContentCachePolicy.shouldRefresh(metadata.lastSeriesSync, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {
- progress(onProgress, "Downloading Series...")
+ progress(provider.id, onProgress, "Downloading Series...")
val catsResult = runCatching { retryTransient { api.getSeriesCategories().getOrThrow("Series categories") } }
catsResult.getOrNull()?.let {
categoryDao.replaceAll(provider.id, "SERIES", it.map { category -> category.toEntity(provider.id) })
@@ -251,7 +274,7 @@ class SyncManager @Inject constructor(
if (force || ContentCachePolicy.shouldRefresh(metadata.lastEpgSync, ContentCachePolicy.EPG_TTL_MILLIS, now)) {
try {
- progress(onProgress, "Downloading EPG...")
+ progress(provider.id, onProgress, "Downloading EPG...")
val base = provider.serverUrl.trimEnd('/')
val xmltvUrl = provider.epgUrl.ifBlank {
XtreamUrlFactory.buildXmltvUrl(base, provider.username, provider.password)
@@ -306,7 +329,7 @@ class SyncManager @Inject constructor(
warnings.add(epgValidationError)
} else {
try {
- progress(onProgress, "Downloading EPG...")
+ progress(provider.id, onProgress, "Downloading EPG...")
retryTransient { epgRepository.refreshEpg(provider.id, currentEpgUrl) }
metadata = metadata.copy(lastEpgSync = now)
syncMetadataRepository.updateMetadata(metadata)
@@ -324,7 +347,7 @@ class SyncManager @Inject constructor(
provider: Provider,
onProgress: ((String) -> Unit)?
) {
- progress(onProgress, "Retrying EPG...")
+ progress(provider.id, onProgress, "Retrying EPG...")
val epgUrl = when (provider.type) {
ProviderType.XTREAM_CODES -> {
val base = provider.serverUrl.trimEnd('/')
@@ -354,7 +377,7 @@ class SyncManager @Inject constructor(
val now = System.currentTimeMillis()
when (provider.type) {
ProviderType.XTREAM_CODES -> {
- progress(onProgress, "Retrying Movies...")
+ progress(provider.id, onProgress, "Retrying Movies...")
val api = XtreamProvider(
providerId = provider.id,
api = xtreamApiService,
@@ -373,7 +396,7 @@ class SyncManager @Inject constructor(
syncMetadataRepository.updateMetadata(metadata)
}
ProviderType.M3U -> {
- progress(onProgress, "Retrying Movies...")
+ progress(provider.id, onProgress, "Retrying Movies...")
val stats = withContext(Dispatchers.IO) {
importM3uPlaylist(provider, onProgress, includeLive = false, includeMovies = true)
}
@@ -394,7 +417,7 @@ class SyncManager @Inject constructor(
if (provider.type != ProviderType.XTREAM_CODES) {
throw IllegalStateException("Series retry is available only for Xtream providers")
}
- progress(onProgress, "Retrying Series...")
+ progress(provider.id, onProgress, "Retrying Series...")
val api = XtreamProvider(
providerId = provider.id,
api = xtreamApiService,
@@ -425,7 +448,7 @@ class SyncManager @Inject constructor(
UrlSecurityPolicy.validatePlaylistSourceUrl(provider.m3uUrl.ifBlank { provider.serverUrl })?.let { message ->
throw IllegalStateException(message)
}
- progress(onProgress, "Downloading Playlist...")
+ progress(provider.id, onProgress, "Downloading Playlist...")
val existingChannelIds = if (includeLive) channelDao.getIdMappings(provider.id).associate { it.remoteId to it.id } else emptyMap()
val existingMovieIds = if (includeMovies) movieDao.getIdMappings(provider.id).associate { it.remoteId to it.id } else emptyMap()
val liveCategories = CategoryAccumulator(provider.id, ContentType.LIVE, 1L)
@@ -445,7 +468,7 @@ class SyncManager @Inject constructor(
var publishedMovieCategoryCount = 0
openPlaylistStream(provider) { streamed ->
- progress(onProgress, "Parsing Playlist...")
+ progress(provider.id, onProgress, "Parsing Playlist...")
maybeDecompressPlaylist(streamed).use { input ->
m3uParser.parseStreaming(
inputStream = input,
@@ -467,7 +490,7 @@ class SyncManager @Inject constructor(
categoryDao.insertAll(movieCategories.entities())
publishedMovieCategoryCount = movieCategories.count
}
- progress(onProgress, "Imported $parsedCount playlist entries...")
+ progress(provider.id, onProgress, "Imported $parsedCount playlist entries...")
nextMilestone += PROGRESS_INTERVAL
}
if (!UrlSecurityPolicy.isAllowedStreamEntryUrl(entry.url)) {
@@ -691,11 +714,16 @@ class SyncManager @Inject constructor(
/** Delegates to M3uParser to avoid duplicate logic. */
internal fun isVodEntry(entry: M3uParser.M3uEntry): Boolean = M3uParser.isVodEntry(entry)
- private fun progress(callback: ((String) -> Unit)?, message: String) {
- _syncState.value = SyncState.Syncing(message)
+ private fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String) {
+ publishSyncState(providerId, SyncState.Syncing(message))
callback?.invoke(message)
}
+ private fun publishSyncState(providerId: Long, state: SyncState) {
+ _syncState.value = state
+ _syncStatesByProvider.update { states -> states + (providerId to state) }
+ }
+
private fun redactUrlForLogs(url: String?): String {
if (url.isNullOrBlank()) return "<empty>"
return runCatching {
@@ -734,6 +762,10 @@ class SyncManager @Inject constructor(
}
private fun isRetryable(error: Throwable): Boolean {
+ if (error is XtreamAuthenticationException) return false
+ if (error is XtreamParsingException) return false
+ if (error is XtreamRequestException) return false
+ if (error is XtreamNetworkException) return true
if (error is IOException) return true
val message = error.message.orEmpty().lowercase()
@@ -753,7 +785,7 @@ class SyncManager @Inject constructor(
return when (this) {
is com.streamvault.domain.model.Result.Success -> data
is com.streamvault.domain.model.Result.Error ->
- throw Exception("Failed to fetch $resourceName: $message")
+ throw exception ?: IllegalStateException("Failed to fetch $resourceName: $message")
is com.streamvault.domain.model.Result.Loading ->
throw Exception("Unexpected loading state for $resourceName")
}
diff --git a/data/src/test/java/com/streamvault/data/remote/xtream/OkHttpXtreamApiServiceTest.kt b/data/src/test/java/com/streamvault/data/remote/xtream/OkHttpXtreamApiServiceTest.kt
new file mode 100644
index 00000000..edee896f
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/remote/xtream/OkHttpXtreamApiServiceTest.kt
@@ -0,0 +1,79 @@
+package com.streamvault.data.remote.xtream
+
+import com.google.common.truth.Truth.assertThat
+import java.net.SocketTimeoutException
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Protocol
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.ResponseBody.Companion.toResponseBody
+import org.junit.Test
+
+class OkHttpXtreamApiServiceTest {
+
+ private val json = Json { ignoreUnknownKeys = true }
+
+ @Test
+ fun `get classifies 401 as authentication error`() = runTest {
+ val service = OkHttpXtreamApiService(
+ client = clientReturning(statusCode = 401, body = "{}"),
+ json = json
+ )
+
+ val failure = runCatching {
+ service.getLiveCategories("https://example.test/player_api.php")
+ }.exceptionOrNull()
+
+ assertThat(failure).isInstanceOf(XtreamAuthenticationException::class.java)
+ assertThat(failure).hasMessageThat().contains("HTTP 401")
+ }
+
+ @Test
+ fun `get classifies malformed JSON as parsing error`() = runTest {
+ val service = OkHttpXtreamApiService(
+ client = clientReturning(statusCode = 200, body = "{not-json}"),
+ json = json
+ )
+
+ val failure = runCatching {
+ service.getLiveCategories("https://example.test/player_api.php")
+ }.exceptionOrNull()
+
+ assertThat(failure).isInstanceOf(XtreamParsingException::class.java)
+ assertThat(failure).hasMessageThat().contains("malformed")
+ }
+
+ @Test
+ fun `get classifies transport failures as network errors`() = runTest {
+ val service = OkHttpXtreamApiService(
+ client = OkHttpClient.Builder()
+ .addInterceptor { throw SocketTimeoutException("timed out") }
+ .build(),
+ json = json
+ )
+
+ val failure = runCatching {
+ service.getLiveCategories("https://example.test/player_api.php")
+ }.exceptionOrNull()
+
+ assertThat(failure).isInstanceOf(XtreamNetworkException::class.java)
+ assertThat(failure).hasMessageThat().contains("timed out")
+ }
+
+ private fun clientReturning(statusCode: Int, body: String): OkHttpClient {
+ return OkHttpClient.Builder()
+ .addInterceptor { chain ->
+ Response.Builder()
+ .request(Request.Builder().url(chain.request().url).build())
+ .protocol(Protocol.HTTP_1_1)
+ .code(statusCode)
+ .message("test")
+ .body(body.toResponseBody("application/json".toMediaType()))
+ .build()
+ }
+ .build()
+ }
+}
\ No newline at end of file
diff --git a/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt b/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt
new file mode 100644
index 00000000..18098556
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt
@@ -0,0 +1,17 @@
+package com.streamvault.data.security
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class CredentialCryptoTest {
+
+ @Test
+ fun `decryptIfNeeded throws credential exception for unreadable encrypted value`() {
+ val failure = runCatching {
+ CredentialCrypto.decryptIfNeeded("enc:v1:not-valid-base64")
+ }.exceptionOrNull()
+
+ assertThat(failure).isInstanceOf(CredentialDecryptionException::class.java)
+ assertThat(failure).hasMessageThat().contains("Please re-enter your provider credentials")
+ }
+}
\ No newline at end of file
diff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerConcurrencyTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerConcurrencyTest.kt
new file mode 100644
index 00000000..4084430a
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/sync/SyncManagerConcurrencyTest.kt
@@ -0,0 +1,165 @@
+package com.streamvault.data.sync
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.local.dao.CategoryDao
+import com.streamvault.data.local.dao.ChannelDao
+import com.streamvault.data.local.dao.MovieDao
+import com.streamvault.data.local.dao.ProviderDao
+import com.streamvault.data.local.dao.SeriesDao
+import com.streamvault.data.local.entity.ProviderEntity
+import com.streamvault.data.parser.M3uParser
+import com.streamvault.data.remote.dto.XtreamAuthResponse
+import com.streamvault.data.remote.dto.XtreamCategory
+import com.streamvault.data.remote.dto.XtreamEpgResponse
+import com.streamvault.data.remote.dto.XtreamSeriesInfoResponse
+import com.streamvault.data.remote.dto.XtreamSeriesItem
+import com.streamvault.data.remote.dto.XtreamStream
+import com.streamvault.data.remote.dto.XtreamVodInfoResponse
+import com.streamvault.data.remote.xtream.XtreamApiService
+import com.streamvault.domain.model.ProviderStatus
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.Result
+import com.streamvault.domain.repository.EpgRepository
+import com.streamvault.domain.repository.SyncMetadataRepository
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.async
+import kotlinx.coroutines.test.runTest
+import okhttp3.OkHttpClient
+import org.junit.Test
+import org.mockito.kotlin.doNothing
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SyncManagerConcurrencyTest {
+
+ @Test
+ fun `sync serializes concurrent provider refreshes`() = runTest {
+ val providerDao = MultiProviderDao(
+ mapOf(
+ 1L to sampleProvider(1L, "alpha"),
+ 2L to sampleProvider(2L, "beta")
+ )
+ )
+ val xtreamApi = BlockingXtreamApiService()
+ val channelDao: ChannelDao = mock()
+ val movieDao: MovieDao = mock()
+ val seriesDao: SeriesDao = mock()
+ val categoryDao: CategoryDao = mock()
+ val epgRepository: EpgRepository = mock()
+ val syncMetadataRepository: SyncMetadataRepository = mock()
+ val okHttpClient: OkHttpClient = mock()
+
+ whenever(syncMetadataRepository.getMetadata(1L)).thenReturn(null)
+ whenever(syncMetadataRepository.getMetadata(2L)).thenReturn(null)
+ doNothing().whenever(syncMetadataRepository).updateMetadata(org.mockito.kotlin.any())
+ whenever(epgRepository.refreshEpg(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(Result.success(Unit))
+
+ val manager = SyncManager(
+ providerDao = providerDao,
+ channelDao = channelDao,
+ movieDao = movieDao,
+ seriesDao = seriesDao,
+ categoryDao = categoryDao,
+ xtreamApiService = xtreamApi,
+ m3uParser = M3uParser(),
+ epgRepository = epgRepository,
+ okHttpClient = okHttpClient,
+ syncMetadataRepository = syncMetadataRepository
+ )
+
+ val firstSync = async { manager.sync(1L, force = true) }
+ xtreamApi.firstLiveCategoriesStarted.await()
+
+ val secondSync = async { manager.sync(2L, force = true) }
+ kotlinx.coroutines.yield()
+
+ assertThat(xtreamApi.liveCategoryRequests).containsExactly("alpha")
+
+ xtreamApi.allowFirstLiveCategories.complete(Unit)
+
+ assertThat(firstSync.await().isSuccess).isTrue()
+ assertThat(secondSync.await().isSuccess).isTrue()
+ assertThat(xtreamApi.liveCategoryRequests).containsExactly("alpha", "beta").inOrder()
+ }
+
+ private class MultiProviderDao(
+ private val providers: Map<Long, ProviderEntity>
+ ) : ProviderDao() {
+ override suspend fun getById(id: Long): ProviderEntity? = providers[id]
+ override suspend fun updateSyncTime(id: Long, timestamp: Long) = Unit
+ override fun getAll() = kotlinx.coroutines.flow.flowOf(providers.values.toList())
+ override fun getActive() = kotlinx.coroutines.flow.flowOf(providers.values.firstOrNull())
+ override suspend fun insert(entity: ProviderEntity): Long = entity.id
+ override suspend fun update(entity: ProviderEntity) = Unit
+ override suspend fun delete(id: Long) = Unit
+ override suspend fun deactivateAll() = Unit
+ override suspend fun activate(id: Long) = Unit
+ override suspend fun getByUrlAndUser(url: String, user: String): ProviderEntity? = null
+ override suspend fun updateEpgUrl(id: Long, epgUrl: String) = Unit
+ override suspend fun setActive(id: Long) = Unit
+ }
+
+ private class BlockingXtreamApiService : XtreamApiService {
+ val firstLiveCategoriesStarted = CompletableDeferred<Unit>()
+ val allowFirstLiveCategories = CompletableDeferred<Unit>()
+ val liveCategoryRequests = mutableListOf<String>()
+
+ override suspend fun authenticate(endpoint: String): XtreamAuthResponse {
+ throw UnsupportedOperationException()
+ }
+
+ override suspend fun getLiveCategories(endpoint: String): List<XtreamCategory> {
+ val marker = when {
+ endpoint.contains("alpha") -> "alpha"
+ endpoint.contains("beta") -> "beta"
+ else -> endpoint
+ }
+ liveCategoryRequests += marker
+ if (liveCategoryRequests.size == 1) {
+ firstLiveCategoriesStarted.complete(Unit)
+ allowFirstLiveCategories.await()
+ }
+ return emptyList()
+ }
+
+ override suspend fun getLiveStreams(endpoint: String): List<XtreamStream> = emptyList()
+
+ override suspend fun getVodCategories(endpoint: String): List<XtreamCategory> = emptyList()
+
+ override suspend fun getVodStreams(endpoint: String): List<XtreamStream> = emptyList()
+
+ override suspend fun getVodInfo(endpoint: String): XtreamVodInfoResponse {
+ throw UnsupportedOperationException()
+ }
+
+ override suspend fun getSeriesCategories(endpoint: String): List<XtreamCategory> = emptyList()
+
+ override suspend fun getSeriesList(endpoint: String): List<XtreamSeriesItem> = emptyList()
+
+ override suspend fun getSeriesInfo(endpoint: String): XtreamSeriesInfoResponse {
+ throw UnsupportedOperationException()
+ }
+
+ override suspend fun getShortEpg(endpoint: String): XtreamEpgResponse {
+ throw UnsupportedOperationException()
+ }
+
+ override suspend fun getFullEpg(endpoint: String): XtreamEpgResponse {
+ throw UnsupportedOperationException()
+ }
+ }
+
+ private companion object {
+ fun sampleProvider(id: Long, username: String) = ProviderEntity(
+ id = id,
+ name = "Provider $username",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = "https://$username.example.com",
+ username = username,
+ password = "password",
+ status = ProviderStatus.UNKNOWN
+ )
+ }
+}
\ No newline at end of file
diff --git a/docs/audit/04_MISSING_FEATURES_COMPLETENESS.md b/docs/audit/04_MISSING_FEATURES_COMPLETENESS.md
new file mode 100644
index 00000000..f1c42092
--- /dev/null
+++ b/docs/audit/04_MISSING_FEATURES_COMPLETENESS.md
@@ -0,0 +1,271 @@
+# StreamVault Pre-Release Audit: Missing Features & Completeness
+
+> **Audit Date:** March 17, 2026
+> **Focus:** Missing functionality, partial implementations, feature gaps for a premium IPTV player
+
+---
+
+## 1. Player Module β€” Missing Premium Features
+
+### 1.1 No Quality/Bitrate Selection [HIGH]
+
+**Current:** Player uses Media3's default adaptive bitrate selection with no user control.
+**Expected:** Premium IPTV players allow users to:
+- View available quality options (Auto, 1080p, 720p, 480p, etc.)
+- Lock to a specific quality
+- Set quality preferences per network type (WiFi vs Ethernet)
+
+**Implementation Path:** Use `DefaultTrackSelector.parameters.setMaxVideoSize()` with user preference. The `constrainResolutionForMultiView` boolean already demonstrates this capability.
+
+### 1.2 No Playback Speed Control [MEDIUM]
+
+**Current:** No speed controls exposed.
+**Expected:** 0.5x, 0.75x, 1x, 1.25x, 1.5x, 2x for VOD content.
+**Implementation Path:** `ExoPlayer.setPlaybackParameters(PlaybackParameters(speed))` β€” trivial to add.
+
+### 1.3 No Audio Track Language Auto-Selection [MEDIUM]
+
+**Current:** Audio track can be selected manually but doesn't default to user's locale.
+**Expected:** Auto-select audio track matching device/app language.
+**Implementation Path:** Use `DefaultTrackSelector.Parameters.setPreferredAudioLanguage()`.
+
+### 1.4 No Subtitle Styling [LOW]
+
+**Current:** Subtitle track can be toggled but styling (size, color, background) is not configurable.
+**Expected:** Standard TV apps allow subtitle customization per accessibility requirements.
+
+### 1.5 No Stream Failover [MEDIUM]
+
+**Current:** `Channel.alternativeStreams` exists as `List<String>` but the player doesn't use it.
+**Expected:** When primary stream fails, automatically try alternative stream URLs.
+**Implementation Path:** On `PlayerError.NetworkError`, try next URL from `alternativeStreams` before showing error.
+
+### 1.6 No Seek Thumbnails / Trick Play [LOW]
+
+**Current:** Seek bar shows position but no visual preview.
+**Expected:** Premium players show thumbnails while scrubbing for VOD content.
+
+### 1.7 No DRM Support [LOW for IPTV]
+
+**Current:** No Widevine, PlayReady, or ClearKey DRM scaffolding.
+**Expected:** Some premium IPTV providers use DRM-protected streams.
+**Note:** Most IPTV providers don't use DRM. Lower priority unless targeting premium content providers.
+
+---
+
+## 2. Domain Module β€” Severely Underdeveloped Use Case Layer
+
+### 2.1 Only 1 Use Case Exists [HIGH]
+
+**Current:** `GetCustomCategories` is the only use case in the entire domain layer.
+**Expected:** A well-architected app should have 15-25+ use cases encapsulating business logic.
+
+**Critical missing use cases:**
+
+| Use Case | Purpose |
+|----------|---------|
+| `SearchContent` | Cross-provider, cross-content-type search |
+| `GetContinueWatching` | Smart resume list with series awareness |
+| `MarkAsWatched` | Explicit watched marking with progress threshold |
+| `ValidateAndAddProvider` | Full validation β†’ login β†’ sync orchestration |
+| `SyncProvider` | Orchestrated sync with progress and error handling |
+| `GetRecommendations` | Based on watch history and favorites |
+| `ScheduleRecording` | With conflict detection and storage checks |
+| `ExportBackup` / `ImportBackup` | With encryption and conflict resolution |
+| `UnlockParentalCategory` | PIN validation with attempt tracking |
+
+**Impact:** Business logic is spread across ViewModels and repositories instead of being centralized in testable use cases.
+
+### 2.2 Domain Models Missing Fields [MEDIUM]
+
+| Model | Missing Field | Purpose |
+|-------|--------------|---------|
+| `Program` | `rating` | Content rating (PG-13, R, etc.) |
+| `Program` | `imageUrl` | Program thumbnail for EPG grid |
+| `Program` | `genre` / `category` | EPG filtering by genre |
+| `Channel` | `qualityOptions` | Available stream qualities |
+| `StreamInfo` | `expirationTime` | Token-based stream URL expiry |
+| `StreamInfo` | `drmInfo` | DRM license/config |
+| `PlaybackHistory` | `watchedStatus` | Explicit watched vs auto-detected |
+| `Provider` | `apiVersion` | Xtream API version compatibility |
+
+### 2.3 Backup Data Incomplete [MEDIUM]
+
+**File:** `domain/src/main/java/com/streamvault/domain/manager/BackupManager.kt`
+
+`BackupData` is missing:
+- Parental control PIN (critical β€” lost on restore)
+- Recording schedules
+- Blocked channels/categories
+- Playback preferences (quality, subtitle language)
+
+### 2.4 Repository Interface Gaps
+
+**Missing methods across repositories:**
+
+| Repository | Missing Method | Purpose |
+|-----------|---------------|---------|
+| ChannelRepository | `getChannelsByNumber()` | EPG guides organize by channel number |
+| ChannelRepository | `getChannelsWithoutErrors()` | Skip problematic streams |
+| EpgRepository | `searchPrograms()` | Find programs across all channels |
+| EpgRepository | `getProgramsByCategory()` | Category-based EPG browsing |
+| MovieRepository | `getRecommendations()` | Based on watch history |
+| MovieRepository | `getRelatedContent()` | Similar genre/cast |
+| PlaybackHistoryRepository | `markAsWatched()` | Explicit watched marking |
+| PlaybackHistoryRepository | `getUnwatchedCount()` | For series tracking |
+| LibraryBrowseQuery | `sortBy` field | Name, date, rating, watch count |
+| LibraryBrowseQuery | `filterBy` field | Unwatched, incomplete, language |
+| LibraryBrowseQuery | `searchQuery` field | Combined search + browse |
+
+---
+
+## 3. Data Module β€” Implementation Gaps
+
+### 3.1 Watch Progress Inconsistency [MEDIUM]
+
+**Description:**
+Movie watch progress is duplicated between two locations:
+- `movies.watch_progress` column (updated via `movieDao.updateWatchProgress()`)
+- `playback_history.resume_position_ms` (updated during playback)
+
+These can get out of sync. Episode watch progress in particular may show `watch_progress=0` in the episodes table while `playback_history` has a valid resume position.
+
+**Action:** Single source of truth β€” either use playback_history exclusively, or add a sync mechanism.
+
+### 3.2 Stale Favorite Cleanup Not Automated [MEDIUM]
+
+**Description:**
+`FavoriteRepositoryImpl` has methods to clean up favorites for deleted content:
+- `deleteMissingLiveFavorites()`
+- `deleteMissingMovieFavorites()`
+- `deleteMissingSeriesFavorites()`
+
+But these are **never called** by any visible code path. The `SyncWorker` β†’ `DatabaseMaintenanceManager` chain doesn't seem to invoke them.
+
+**Impact:** Favorites for deleted channels/movies/series remain in the database forever as orphaned entries.
+
+**Action:** Wire cleanup methods into the maintenance worker or post-sync hook.
+
+### 3.3 Xtream Expiration Date β€” Limited Format Support [LOW]
+
+**File:** `data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt`
+
+Only 2 date formats are tried (`yyyy-MM-dd HH:mm:ss`, `yyyy-MM-dd`). Some Xtream providers use additional formats. Also missing timezone handling (assumes local time instead of UTC).
+
+### 3.4 Search Results Not Ranked [LOW]
+
+**Description:**
+FTS4 search queries return results in arbitrary order. Room FTS4 doesn't provide ranking by default.
+
+**Impact:** Search for "Sports" may show "Sports Bar" before "Sports Channel" with no relevance ordering.
+
+**Recommendation:**
+Consider adding a simple relevance heuristic (exact match first, prefix match second, contains match third).
+
+---
+
+## 4. Test Coverage Gaps
+
+### 4.1 Current Test Inventory
+
+| Module | Unit Tests | Android Tests | Coverage Estimate |
+|--------|-----------|---------------|-------------------|
+| **domain** | 3 files (25 tests) | 0 | ~10% |
+| **data** | 6 files | 3 files | ~25% |
+| **app** | 4 files | 4 files | ~15% |
+| **player** | 1 file (18 tests) | 0 | ~20% |
+| **TOTAL** | **14 files** | **7 files** | **~15-20%** |
+
+### 4.2 Critical Missing Tests
+
+| Test Category | What's Missing | Priority |
+|--------------|----------------|----------|
+| **Security** | CredentialCrypto encrypt/decrypt, UrlSecurityPolicy validation, ProviderInputSanitizer bounds | HIGH |
+| **Database Migrations** | Full v1β†’v13 data integrity verification | HIGH |
+| **Error Paths** | Network failure handling, malformed data recovery, timeout behavior | HIGH |
+| **Player Engine** | Playback lifecycle, error recovery, audio focus, track selection | MEDIUM |
+| **ViewModels** | MoviesViewModel, SeriesViewModel, SettingsViewModel, PlayerViewModel | MEDIUM |
+| **Repositories** | Full CRUD operations with edge cases | MEDIUM |
+| **Integration** | Provider login β†’ sync β†’ display β†’ playback end-to-end flow | LOW |
+| **UI/Golden** | More composable snapshot tests for visual regression | LOW |
+
+### 4.3 CI/CD Test Pipeline Issues
+
+- `--continue` flag masks individual test failures
+- No code coverage reporting (Jacoco)
+- No release build testing
+- No ProGuard/R8 validation for release APK
+
+---
+
+## 5. Recording System β€” Interface vs Implementation Gaps
+
+### 5.1 RecordingManager Implementation Exists βœ…
+
+The `RecordingManagerImpl` is fully implemented with:
+- Manual recording start/stop
+- Scheduled recording
+- Storage state monitoring
+- Active job management
+
+### 5.2 Missing Recording Features [LOW]
+
+| Feature | Status |
+|---------|--------|
+| Recurring recordings (daily/weekly) | ❌ Not implemented |
+| Recording conflict detection | ❌ Not implemented |
+| Automatic storage cleanup | ❌ Not implemented |
+| Pause/resume recording | ❌ Not implemented |
+| Series recording rules | ❌ Not implemented |
+
+---
+
+## 6. Backup System β€” Interface vs Implementation Gaps
+
+### 6.1 BackupManager Implementation Exists βœ…
+
+The `BackupManagerImpl` is fully implemented with:
+- Export with checksum verification
+- Import with conflict detection
+- Version handling
+
+### 6.2 Missing Backup Features [LOW]
+
+| Feature | Status |
+|---------|--------|
+| Encrypted backup | ❌ Not implemented |
+| Cloud backup (Google Drive) | ❌ Not implemented |
+| Automatic scheduled backup | ❌ Not implemented |
+| Selective restore (only favorites, only providers, etc.) | ❌ Not implemented |
+
+---
+
+## 7. Localization Completeness
+
+**Status:** βœ… Well-implemented β€” 25+ languages supported via translation scripts.
+
+All user-facing strings use `stringResource(R.string.*)`. Only non-localizable symbols (`+`, `!`, `β€’`) are hardcoded.
+
+**Note:** RTL support (Hebrew, Arabic) was implemented in Phase 5 with proper mirroring.
+
+---
+
+## 8. Summary: Feature Readiness Matrix
+
+| Feature Area | Readiness | Blocking? |
+|-------------|-----------|-----------|
+| Live TV Playback | 90% | No |
+| VOD (Movies/Series) | 80% | **Yes** β€” dead code in category browsing |
+| EPG Guide | 85% | No |
+| Provider Management | 90% | No |
+| Favorites & Groups | 85% | No |
+| Parental Controls | 70% | **Yes** β€” in-memory only |
+| Search | 75% | No |
+| Multi-View | 80% | No |
+| Settings | 85% | No |
+| Player Controls | 75% | No β€” but missing quality selection |
+| Recording | 60% | No β€” functional but basic |
+| Backup/Restore | 70% | No β€” functional but missing PIN backup |
+| Android TV Platform | 50% | **Yes** β€” missing Watch Next, voice search |
+| Accessibility | 60% | No β€” functional but gaps |
+| Test Coverage | 20% | **Yes** β€” too low for production confidence |
diff --git a/docs/audit/tv-compose-accessibility.md b/docs/audit/tv-compose-accessibility.md
new file mode 100644
index 00000000..314546f3
--- /dev/null
+++ b/docs/audit/tv-compose-accessibility.md
@@ -0,0 +1,83 @@
+# TV Compose And Accessibility Notes
+
+Last updated: 2026-03-18
+
+## Compose for TV dependency status
+
+- `androidx.tv:tv-material` is pinned in `gradle/libs.versions.toml` at `1.0.1`.
+- The original audit note about `1.0.0-alpha12` is outdated.
+- The dependency itself is now stable, but not every API used by the app is fully non-experimental.
+
+## Remaining experimental TV Material usage
+
+Current known `ExperimentalTvMaterial3Api` usage is intentionally limited to:
+
+- `FilterChip` usage in `SearchScreen`
+ - file: `app/src/main/java/com/streamvault/app/ui/screens/search/SearchScreen.kt`
+
+Why this matters:
+
+- future TV Material updates may still require migration work for this surface
+- the risk is now localized instead of spread across the UI layer
+
+Recommended update process:
+
+1. update `compose-tv-material` only after TV regression testing
+2. compile the app and verify `SearchScreen` first
+3. retest D-pad focus behavior and chip selection visuals in search
+
+## Accessibility status
+
+### Implemented
+
+- content descriptions already have broad coverage across interactive TV surfaces
+- reduced motion support now respects `Settings.Global.ANIMATOR_DURATION_SCALE`
+- shimmer loading states disable animation when reduced motion is enabled
+- Coil image crossfades disable when reduced motion is enabled
+- focus ring visibility was strengthened by increasing shared focus border widths
+
+### Current behavior
+
+Reduced motion implementation is centralized in:
+
+- `app/src/main/java/com/streamvault/app/ui/accessibility/MotionPreferences.kt`
+
+Shared motion-sensitive paths currently covered:
+
+- `app/src/main/java/com/streamvault/app/ui/components/SkeletonLoader.kt`
+- `app/src/main/java/com/streamvault/app/ui/components/AsyncImageModels.kt`
+- `app/src/main/java/com/streamvault/app/StreamVaultApp.kt`
+
+Shared focus ring sizing is defined in:
+
+- `app/src/main/java/com/streamvault/app/ui/design/FocusSpec.kt`
+
+### Still open
+
+- no dedicated high-contrast mode
+- no app-level text scaling strategy beyond system defaults
+- no documented TalkBack validation pass yet
+- some nonessential UI animations still exist outside the shared shimmer and image paths
+
+## Manual validation checklist
+
+### Reduced motion
+
+1. Set system animation scale to `0x` on the Android TV device or emulator.
+2. Open screens that show skeleton loaders and poster artwork.
+3. Confirm:
+ - shimmer does not animate
+ - image loads do not crossfade
+ - the UI remains readable and responsive
+
+### Focus visibility
+
+1. Navigate Home, Search, EPG, Settings, and Player overlays using only the D-pad.
+2. Confirm the focused element remains obvious from couch distance on a large display.
+3. Recheck on bright and dark content backgrounds.
+
+### TalkBack
+
+1. Enable TalkBack on device.
+2. Verify Search, Home shelves, player controls, and settings rows are announced in a useful order.
+3. Verify locked content, action buttons, and back navigation controls have meaningful labels.
diff --git a/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt b/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt
index 012521e0..79a7625e 100644
--- a/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt
+++ b/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt
@@ -1,41 +1,144 @@
package com.streamvault.domain.manager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.update
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
-class ParentalControlManager @Inject constructor() {
+class ParentalControlManager @Inject constructor(
+ private val sessionStore: ParentalControlSessionStore
+) {
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+ private val stateLock = Any()
+ private var expirationJob: Job? = null
+ private val _sessionState = MutableStateFlow(normalizeState(sessionStore.readSessionState(), currentTimeMs()))
private val _unlockedCategoriesByProvider = MutableStateFlow<Map<Long, Set<Long>>>(emptyMap())
val unlockedCategoriesByProvider: StateFlow<Map<Long, Set<Long>>> =
_unlockedCategoriesByProvider.asStateFlow()
+ val unlockTimeoutMs: StateFlow<Long>
+ get() = MutableStateFlow(_sessionState.value.unlockTimeoutMs).asStateFlow()
+
+ init {
+ publishState(_sessionState.value, persist = true, nowMs = currentTimeMs())
+ }
+
fun unlockedCategoriesForProvider(providerId: Long) =
unlockedCategoriesByProvider.map { it[providerId] ?: emptySet() }
- fun unlockCategory(providerId: Long, categoryId: Long) {
- _unlockedCategoriesByProvider.update { current ->
- val providerSet = (current[providerId] ?: emptySet()) + categoryId
- current + (providerId to providerSet)
+ fun unlockCategory(providerId: Long, categoryId: Long, nowMs: Long = currentTimeMs()) {
+ synchronized(stateLock) {
+ val state = refreshLocked(nowMs)
+ val providerEntries = state.unlockedCategoryExpirationsByProvider[providerId].orEmpty() +
+ (categoryId to (nowMs + state.unlockTimeoutMs))
+ publishState(
+ state.copy(
+ unlockedCategoryExpirationsByProvider = state.unlockedCategoryExpirationsByProvider +
+ (providerId to providerEntries)
+ ),
+ nowMs = nowMs
+ )
}
}
- fun isCategoryUnlocked(providerId: Long, categoryId: Long): Boolean {
- return _unlockedCategoriesByProvider.value[providerId]?.contains(categoryId) == true
+ fun isCategoryUnlocked(providerId: Long, categoryId: Long, nowMs: Long = currentTimeMs()): Boolean {
+ synchronized(stateLock) {
+ val state = refreshLocked(nowMs)
+ return state.unlockedCategoryExpirationsByProvider[providerId]?.get(categoryId)?.let { it > nowMs } == true
+ }
+ }
+
+ fun setUnlockTimeout(timeoutMs: Long) {
+ synchronized(stateLock) {
+ val state = refreshLocked(currentTimeMs())
+ publishState(state.copy(unlockTimeoutMs = normalizeTimeout(timeoutMs)), nowMs = currentTimeMs())
+ }
+ }
+
+ fun refreshSessionState(nowMs: Long = currentTimeMs()) {
+ synchronized(stateLock) {
+ publishState(normalizeState(sessionStore.readSessionState(), nowMs), persist = true, nowMs = nowMs)
+ }
}
fun clearUnlockedCategories(providerId: Long? = null) {
- if (providerId == null) {
- _unlockedCategoriesByProvider.value = emptyMap()
- return
+ synchronized(stateLock) {
+ val state = refreshLocked(currentTimeMs())
+ val updatedUnlocks = if (providerId == null) {
+ emptyMap()
+ } else {
+ state.unlockedCategoryExpirationsByProvider - providerId
+ }
+ publishState(state.copy(unlockedCategoryExpirationsByProvider = updatedUnlocks), nowMs = currentTimeMs())
+ }
+ }
+
+ private fun refreshLocked(nowMs: Long): ParentalControlSessionState {
+ val normalized = normalizeState(_sessionState.value, nowMs)
+ if (normalized != _sessionState.value) {
+ publishState(normalized, nowMs = nowMs)
}
+ return normalized
+ }
- _unlockedCategoriesByProvider.update { current ->
- current - providerId
+ private fun publishState(
+ state: ParentalControlSessionState,
+ persist: Boolean = true,
+ nowMs: Long = currentTimeMs()
+ ) {
+ val normalized = normalizeState(state, nowMs)
+ _sessionState.value = normalized
+ _unlockedCategoriesByProvider.value = normalized.unlockedCategoryExpirationsByProvider
+ .mapValues { (_, categories) -> categories.keys }
+ .filterValues { it.isNotEmpty() }
+
+ if (persist) {
+ sessionStore.writeSessionState(normalized)
}
+ scheduleExpiration(normalized)
}
+
+ private fun scheduleExpiration(state: ParentalControlSessionState) {
+ expirationJob?.cancel()
+ val nextExpiration = state.unlockedCategoryExpirationsByProvider.values
+ .flatMap { it.values }
+ .minOrNull()
+ ?: return
+ val delayMs = nextExpiration - currentTimeMs()
+ if (delayMs <= 0L) {
+ refreshSessionState()
+ return
+ }
+ expirationJob = scope.launch {
+ delay(delayMs)
+ refreshSessionState()
+ }
+ }
+
+ private fun normalizeState(state: ParentalControlSessionState, nowMs: Long): ParentalControlSessionState {
+ val prunedUnlocks = state.unlockedCategoryExpirationsByProvider
+ .mapValues { (_, categories) ->
+ categories.filterValues { expiresAt -> expiresAt > nowMs }
+ }
+ .filterValues { it.isNotEmpty() }
+
+ return state.copy(
+ unlockedCategoryExpirationsByProvider = prunedUnlocks,
+ unlockTimeoutMs = normalizeTimeout(state.unlockTimeoutMs)
+ )
+ }
+
+ private fun normalizeTimeout(timeoutMs: Long): Long =
+ timeoutMs.coerceAtLeast(ParentalControlSessionState.MIN_UNLOCK_TIMEOUT_MS)
+
+ private fun currentTimeMs(): Long = System.currentTimeMillis()
}
diff --git a/domain/src/main/java/com/streamvault/domain/manager/ParentalControlSessionStore.kt b/domain/src/main/java/com/streamvault/domain/manager/ParentalControlSessionStore.kt
new file mode 100644
index 00000000..a6c3bee0
--- /dev/null
+++ b/domain/src/main/java/com/streamvault/domain/manager/ParentalControlSessionStore.kt
@@ -0,0 +1,16 @@
+package com.streamvault.domain.manager
+
+data class ParentalControlSessionState(
+ val unlockedCategoryExpirationsByProvider: Map<Long, Map<Long, Long>> = emptyMap(),
+ val unlockTimeoutMs: Long = DEFAULT_UNLOCK_TIMEOUT_MS
+) {
+ companion object {
+ const val DEFAULT_UNLOCK_TIMEOUT_MS: Long = 30 * 60 * 1000L
+ const val MIN_UNLOCK_TIMEOUT_MS: Long = 60 * 1000L
+ }
+}
+
+interface ParentalControlSessionStore {
+ fun readSessionState(): ParentalControlSessionState
+ fun writeSessionState(state: ParentalControlSessionState)
+}
\ No newline at end of file
diff --git a/domain/src/main/java/com/streamvault/domain/repository/CategoryRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/CategoryRepository.kt
index 9dfafe09..2bbabe60 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/CategoryRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/CategoryRepository.kt
@@ -2,6 +2,7 @@ package com.streamvault.domain.repository
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.Result
import kotlinx.coroutines.flow.Flow
interface CategoryRepository {
@@ -11,5 +12,5 @@ interface CategoryRepository {
categoryId: Long,
type: ContentType,
isProtected: Boolean
- )
+ ): Result<Unit>
}
diff --git a/domain/src/main/java/com/streamvault/domain/repository/ChannelRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/ChannelRepository.kt
index 704b0da4..36438244 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/ChannelRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/ChannelRepository.kt
@@ -13,14 +13,11 @@ interface ChannelRepository {
fun getCategories(providerId: Long): Flow<List<Category>>
fun searchChannels(providerId: Long, query: String): Flow<List<Channel>>
suspend fun getChannel(channelId: Long): Channel?
- @Deprecated("Use getStreamInfo() for richer metadata", replaceWith = ReplaceWith("getStreamInfo(channel)"))
- suspend fun getStreamUrl(channel: Channel): Result<String>
- suspend fun getStreamInfo(channel: Channel): Result<StreamInfo> =
- getStreamUrl(channel).map { StreamInfo(it) }
+ suspend fun getStreamInfo(channel: Channel): Result<StreamInfo>
suspend fun refreshChannels(providerId: Long): Result<Unit>
fun getChannelsByIds(ids: List<Long>): Flow<List<Channel>>
- suspend fun incrementChannelErrorCount(channelId: Long)
- suspend fun resetChannelErrorCount(channelId: Long)
+ suspend fun incrementChannelErrorCount(channelId: Long): Result<Unit>
+ suspend fun resetChannelErrorCount(channelId: Long): Result<Unit>
companion object {
const val ALL_CHANNELS_ID = -1_000_000L
diff --git a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt
index 5f08838f..90547872 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt
@@ -24,11 +24,8 @@ interface MovieRepository {
fun searchMovies(providerId: Long, query: String): Flow<List<Movie>>
suspend fun getMovie(movieId: Long): Movie?
suspend fun getMovieDetails(providerId: Long, movieId: Long): Result<Movie>
- @Deprecated("Use getStreamInfo() for richer metadata", replaceWith = ReplaceWith("getStreamInfo(movie)"))
- suspend fun getStreamUrl(movie: Movie): Result<String>
- suspend fun getStreamInfo(movie: Movie): Result<StreamInfo> =
- getStreamUrl(movie).map { StreamInfo(it) }
+ suspend fun getStreamInfo(movie: Movie): Result<StreamInfo>
suspend fun refreshMovies(providerId: Long): Result<Unit>
- suspend fun updateWatchProgress(movieId: Long, progress: Long)
+ suspend fun updateWatchProgress(movieId: Long, progress: Long): Result<Unit>
suspend fun getWatchProgress(movieId: Long): Long? = null
}
diff --git a/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.kt
index 889802f0..45ce739c 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.kt
@@ -2,6 +2,7 @@ package com.streamvault.domain.repository
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.Result
import kotlinx.coroutines.flow.Flow
interface PlaybackHistoryRepository {
@@ -9,9 +10,9 @@ interface PlaybackHistoryRepository {
fun getRecentlyWatchedByProvider(providerId: Long, limit: Int = 100): Flow<List<PlaybackHistory>>
suspend fun getPlaybackHistory(contentId: Long, contentType: ContentType, providerId: Long): PlaybackHistory?
- suspend fun recordPlayback(history: PlaybackHistory)
- suspend fun updateResumePosition(history: PlaybackHistory)
- suspend fun removeFromHistory(contentId: Long, contentType: ContentType, providerId: Long)
- suspend fun clearAllHistory()
- suspend fun clearHistoryForProvider(providerId: Long)
+ suspend fun recordPlayback(history: PlaybackHistory): Result<Unit>
+ suspend fun updateResumePosition(history: PlaybackHistory): Result<Unit>
+ suspend fun removeFromHistory(contentId: Long, contentType: ContentType, providerId: Long): Result<Unit>
+ suspend fun clearAllHistory(): Result<Unit>
+ suspend fun clearHistoryForProvider(providerId: Long): Result<Unit>
}
diff --git a/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt
index b07b12f8..6758ce2d 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt
@@ -25,10 +25,7 @@ interface SeriesRepository {
fun searchSeries(providerId: Long, query: String): Flow<List<Series>>
suspend fun getSeriesById(seriesId: Long): Series?
suspend fun getSeriesDetails(providerId: Long, seriesId: Long): Result<Series>
- @Deprecated("Use getEpisodeStreamInfo() for richer metadata", replaceWith = ReplaceWith("getEpisodeStreamInfo(episode)"))
- suspend fun getEpisodeStreamUrl(episode: Episode): Result<String>
- suspend fun getEpisodeStreamInfo(episode: Episode): Result<StreamInfo> =
- getEpisodeStreamUrl(episode).map { StreamInfo(it) }
+ suspend fun getEpisodeStreamInfo(episode: Episode): Result<StreamInfo>
suspend fun refreshSeries(providerId: Long): Result<Unit>
- suspend fun updateEpisodeWatchProgress(episodeId: Long, progress: Long)
+ suspend fun updateEpisodeWatchProgress(episodeId: Long, progress: Long): Result<Unit>
}
diff --git a/domain/src/test/java/com/streamvault/domain/manager/ParentalControlManagerTest.kt b/domain/src/test/java/com/streamvault/domain/manager/ParentalControlManagerTest.kt
index 301c3e35..46c53324 100644
--- a/domain/src/test/java/com/streamvault/domain/manager/ParentalControlManagerTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/manager/ParentalControlManagerTest.kt
@@ -9,10 +9,14 @@ import org.junit.Test
class ParentalControlManagerTest {
private lateinit var manager: ParentalControlManager
+ private lateinit var store: FakeParentalControlSessionStore
+ private var baseNow: Long = 0L
@Before
fun setup() {
- manager = ParentalControlManager()
+ store = FakeParentalControlSessionStore()
+ manager = ParentalControlManager(store)
+ baseNow = System.currentTimeMillis() + 10_000L
}
@Test
@@ -23,52 +27,52 @@ class ParentalControlManagerTest {
@Test
fun `unlockCategory makes category accessible`() {
- manager.unlockCategory(1L, 100L)
- assertThat(manager.isCategoryUnlocked(1L, 100L)).isTrue()
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 1)).isTrue()
}
@Test
fun `unlockCategory is scoped to provider`() {
- manager.unlockCategory(1L, 100L)
- assertThat(manager.isCategoryUnlocked(1L, 100L)).isTrue()
- assertThat(manager.isCategoryUnlocked(2L, 100L)).isFalse()
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 1)).isTrue()
+ assertThat(manager.isCategoryUnlocked(2L, 100L, nowMs = baseNow + 1)).isFalse()
}
@Test
fun `multiple categories can be unlocked per provider`() {
- manager.unlockCategory(1L, 100L)
- manager.unlockCategory(1L, 200L)
- assertThat(manager.isCategoryUnlocked(1L, 100L)).isTrue()
- assertThat(manager.isCategoryUnlocked(1L, 200L)).isTrue()
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+ manager.unlockCategory(1L, 200L, nowMs = baseNow)
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 1)).isTrue()
+ assertThat(manager.isCategoryUnlocked(1L, 200L, nowMs = baseNow + 1)).isTrue()
}
@Test
fun `clearUnlockedCategories with provider clears that provider only`() {
- manager.unlockCategory(1L, 100L)
- manager.unlockCategory(2L, 200L)
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+ manager.unlockCategory(2L, 200L, nowMs = baseNow)
manager.clearUnlockedCategories(1L)
- assertThat(manager.isCategoryUnlocked(1L, 100L)).isFalse()
- assertThat(manager.isCategoryUnlocked(2L, 200L)).isTrue()
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 1)).isFalse()
+ assertThat(manager.isCategoryUnlocked(2L, 200L, nowMs = baseNow + 1)).isTrue()
}
@Test
fun `clearUnlockedCategories without provider clears all`() {
- manager.unlockCategory(1L, 100L)
- manager.unlockCategory(2L, 200L)
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+ manager.unlockCategory(2L, 200L, nowMs = baseNow)
manager.clearUnlockedCategories()
- assertThat(manager.isCategoryUnlocked(1L, 100L)).isFalse()
- assertThat(manager.isCategoryUnlocked(2L, 200L)).isFalse()
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 1)).isFalse()
+ assertThat(manager.isCategoryUnlocked(2L, 200L, nowMs = baseNow + 1)).isFalse()
assertThat(manager.unlockedCategoriesByProvider.value).isEmpty()
}
@Test
fun `unlockedCategoriesForProvider emits correct set`() = runTest {
- manager.unlockCategory(1L, 100L)
- manager.unlockCategory(1L, 200L)
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+ manager.unlockCategory(1L, 200L, nowMs = baseNow)
val unlocked = manager.unlockedCategoriesForProvider(1L).first()
assertThat(unlocked).containsExactly(100L, 200L)
@@ -82,9 +86,54 @@ class ParentalControlManagerTest {
@Test
fun `unlocking same category twice is idempotent`() {
- manager.unlockCategory(1L, 100L)
- manager.unlockCategory(1L, 100L)
- assertThat(manager.isCategoryUnlocked(1L, 100L)).isTrue()
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+ manager.unlockCategory(1L, 100L, nowMs = baseNow + 1_000L)
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 1_001L)).isTrue()
assertThat(manager.unlockedCategoriesByProvider.value[1L]).hasSize(1)
}
+
+ @Test
+ fun `refreshSessionState prunes expired unlocks from persisted store`() {
+ store.state = ParentalControlSessionState(
+ unlockedCategoryExpirationsByProvider = mapOf(
+ 1L to mapOf(
+ 100L to (baseNow - 500L),
+ 200L to (baseNow + 2_000L)
+ )
+ )
+ )
+
+ manager.refreshSessionState(nowMs = baseNow)
+
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow)).isFalse()
+ assertThat(manager.isCategoryUnlocked(1L, 200L, nowMs = baseNow)).isTrue()
+ assertThat(store.state.unlockedCategoryExpirationsByProvider[1L]).containsKey(200L)
+ assertThat(store.state.unlockedCategoryExpirationsByProvider[1L]).doesNotContainKey(100L)
+ }
+
+ @Test
+ fun `setUnlockTimeout persists minimum normalized timeout`() {
+ manager.setUnlockTimeout(5_000L)
+
+ assertThat(store.state.unlockTimeoutMs).isEqualTo(ParentalControlSessionState.MIN_UNLOCK_TIMEOUT_MS)
+ }
+
+ @Test
+ fun `unlockCategory expires after timeout`() {
+ manager.setUnlockTimeout(60_000L)
+ manager.unlockCategory(1L, 100L, nowMs = baseNow)
+
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 59_999L)).isTrue()
+ assertThat(manager.isCategoryUnlocked(1L, 100L, nowMs = baseNow + 60_000L)).isFalse()
+ }
+
+ private class FakeParentalControlSessionStore : ParentalControlSessionStore {
+ var state: ParentalControlSessionState = ParentalControlSessionState()
+
+ override fun readSessionState(): ParentalControlSessionState = state
+
+ override fun writeSessionState(state: ParentalControlSessionState) {
+ this.state = state
+ }
+ }
}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 3c068f5f..2c81da4e 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -4,6 +4,8 @@ kotlin = "2.2.0"
ksp = "2.2.0-2.0.2"
compose-bom = "2025.06.01"
compose-tv-foundation = "1.0.0-beta01"
+# Pinned intentionally; stable as of 2026-03-18, update only after TV regression testing.
+# Remaining experimental TV Material usage is limited to FilterChip in SearchScreen.
compose-tv-material = "1.0.1"
media3 = "1.9.2"
room = "2.8.4"
@@ -17,9 +19,13 @@ coroutines = "1.10.2"
lifecycle = "2.10.0"
navigation-compose = "2.9.7"
datastore = "1.2.1"
+security-crypto = "1.1.0-alpha06"
gson = "2.11.0"
kotlinx-serialization = "1.9.0"
work = "2.11.1"
+appcompat = "1.7.1"
+mediarouter = "1.8.1"
+play-services-cast-framework = "22.1.0"
# Test
junit = "4.13.2"
truth = "1.4.4"
@@ -89,11 +95,15 @@ coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutin
# DataStore
datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }
+security-crypto = { group = "androidx.security", name = "security-crypto", version.ref = "security-crypto" }
# Core
core-ktx = { group = "androidx.core", name = "core-ktx", version = "1.18.0" }
activity-compose = { group = "androidx.activity", name = "activity-compose", version = "1.13.0" }
work-runtime-ktx = { group = "androidx.work", name = "work-runtime-ktx", version.ref = "work" }
+appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
+mediarouter = { group = "androidx.mediarouter", name = "mediarouter", version.ref = "mediarouter" }
+play-services-cast-framework = { group = "com.google.android.gms", name = "play-services-cast-framework", version.ref = "play-services-cast-framework" }
# Test
junit = { group = "junit", name = "junit", version.ref = "junit" }
diff --git a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
index 638d589d..b5927198 100644
--- a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
+++ b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
@@ -46,6 +46,7 @@ import kotlin.math.abs
import okhttp3.OkHttpClient
import javax.inject.Inject
import javax.inject.Singleton
+import java.util.Locale
@OptIn(UnstableApi::class)
class Media3PlayerEngine @Inject constructor(
@@ -63,6 +64,14 @@ class Media3PlayerEngine @Inject constructor(
* Set to true for multi-view slots so each instance doesn't compete for 4K bandwidth.
*/
var constrainResolutionForMultiView: Boolean = false
+ /**
+ * Multi-view slots should not compete for global audio focus; only the audible slot needs volume.
+ */
+ var bypassAudioFocus: Boolean = false
+ /**
+ * Auxiliary players do not need MediaSession registration.
+ */
+ var enableMediaSession: Boolean = true
private var pollingJob: Job? = null
private var lastStreamInfo: StreamInfo? = null
private var retryCount = 0
@@ -172,7 +181,9 @@ class Media3PlayerEngine @Inject constructor(
private fun getOrCreatePlayer(): ExoPlayer {
return exoPlayer ?: createPlayer().also {
exoPlayer = it
- mediaSession = MediaSession.Builder(context, it).build()
+ if (enableMediaSession) {
+ mediaSession = MediaSession.Builder(context, it).build()
+ }
}
}
@@ -368,7 +379,7 @@ class Media3PlayerEngine @Inject constructor(
for (i in 0 until group.length) {
val format = group.mediaTrackGroup.getFormat(i)
val id = format.id ?: "${group.mediaTrackGroup.hashCode()}_$i"
- val name = format.label ?: format.language ?: "Track ${i + 1}"
+ val name = buildTrackName(format = format, trackType = type, index = i)
val isSelected = group.isTrackSelected(i)
val track = PlayerTrack(
@@ -405,7 +416,18 @@ class Media3PlayerEngine @Inject constructor(
_error.tryEmit(null)
_playerStats.value = PlayerStats() // reset stats
_mediaTitle.value = null
+ _availableAudioTracks.value = emptyList()
+ _availableSubtitleTracks.value = emptyList()
applyPlayerVolume()
+ player.trackSelectionParameters = player.trackSelectionParameters
+ .buildUpon()
+ .clearOverridesOfType(C.TRACK_TYPE_AUDIO)
+ .clearOverridesOfType(C.TRACK_TYPE_TEXT)
+ .clearOverridesOfType(C.TRACK_TYPE_VIDEO)
+ .setTrackTypeDisabled(C.TRACK_TYPE_AUDIO, false)
+ .setTrackTypeDisabled(C.TRACK_TYPE_TEXT, true)
+ .setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, false)
+ .build()
// If we already preloaded this exact stream, use the cached source
val mediaSource = if (preloadedStreamInfo?.url == streamInfo.url && preloadedSource != null) {
@@ -688,6 +710,54 @@ class Media3PlayerEngine @Inject constructor(
_mediaTitle.value = null
}
+ private fun buildTrackName(format: Format, trackType: Int, index: Int): String {
+ val explicitLabel = format.label
+ ?.trim()
+ ?.takeIf { it.isNotBlank() && !it.matches(Regex("(?i)^track\\s*\\d+$")) }
+
+ if (explicitLabel != null) {
+ return explicitLabel
+ }
+
+ val parts = mutableListOf<String>()
+ val languageCode = format.language
+ ?.takeIf { it.isNotBlank() && it != C.LANGUAGE_UNDETERMINED }
+
+ languageCode?.let { code ->
+ val locale = Locale.forLanguageTag(code)
+ val displayLanguage = locale.getDisplayLanguage(Locale.getDefault())
+ .takeIf { it.isNotBlank() }
+ ?: locale.displayLanguage.takeIf { it.isNotBlank() }
+ if (!displayLanguage.isNullOrBlank()) {
+ parts += displayLanguage.replaceFirstChar { char ->
+ if (char.isLowerCase()) char.titlecase(Locale.getDefault()) else char.toString()
+ }
+ }
+ }
+
+ if (trackType == C.TRACK_TYPE_TEXT) {
+ if ((format.selectionFlags and C.SELECTION_FLAG_FORCED) != 0) {
+ parts += "Forced"
+ }
+ if ((format.roleFlags and C.ROLE_FLAG_CAPTION) != 0) {
+ parts += "CC"
+ }
+ if ((format.roleFlags and C.ROLE_FLAG_DESCRIBES_MUSIC_AND_SOUND) != 0) {
+ parts += "SDH"
+ }
+ }
+
+ if (parts.isNotEmpty()) {
+ return parts.joinToString(" ")
+ }
+
+ return when (trackType) {
+ C.TRACK_TYPE_AUDIO -> "Audio ${index + 1}"
+ C.TRACK_TYPE_TEXT -> "Subtitle ${index + 1}"
+ else -> "Track ${index + 1}"
+ }
+ }
+
private fun isRecoverableError(error: PlaybackException): Boolean {
return when (error.errorCode) {
PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
@@ -790,6 +860,13 @@ class Media3PlayerEngine @Inject constructor(
}
private fun requestAudioFocusIfNeeded(): Boolean {
+ if (bypassAudioFocus) {
+ if (isDucked) {
+ isDucked = false
+ applyPlayerVolume()
+ }
+ return true
+ }
if (hasAudioFocus) {
if (isDucked) {
isDucked = false