StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Integrate TV platform, playback, and UX improvements
Davidona04949b892706
diff --git a/README.md b/README.mdindex 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 Starteddiff --git a/app/build.gradle.kts b/app/build.gradle.ktsindex 0f45a908..3ff5e917 100644--- a/app/build.gradle.kts+++ b/app/build.gradle.kts@@ -94,6 +94,10 @@ dependencies {// Media3implementation(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 {// Coreimplementation(libs.core.ktx)implementation(libs.coroutines.android)+ implementation(libs.appcompat)+ implementation(libs.mediarouter)+ implementation(libs.play.services.cast.framework)// TesttestImplementation(libs.junit)diff --git a/app/proguard-rules.pro b/app/proguard-rules.proindex 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 thediff --git a/app/src/androidTest/java/com/streamvault/app/tv/LauncherProviderInstrumentationTest.kt b/app/src/androidTest/java/com/streamvault/app/tv/LauncherProviderInstrumentationTest.ktnew file mode 100644index 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 filediff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xmlindex 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-featureandroid: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.ktindex 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.Intentimport android.app.PictureInPictureParamsimport android.os.Bundleimport android.os.Build@@ -7,7 +9,15 @@ import android.os.StrictModeimport android.util.Rationalimport androidx.activity.ComponentActivityimport androidx.activity.compose.setContent+import androidx.lifecycle.lifecycleScope+import com.streamvault.app.cast.CastManager+import com.streamvault.app.cast.CastRouteChooserActivityimport 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.TvInputChannelSyncManagerimport com.streamvault.app.ui.theme.StreamVaultThemeimport dagger.hilt.android.AndroidEntryPoint@@ -28,13 +38,20 @@ import android.content.Contextimport android.content.ContextWrapperimport android.content.res.AssetManagerimport android.content.res.Resources+import android.speech.RecognizerIntentimport kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.flow.StateFlowimport kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.launch@AndroidEntryPointclass 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() {@Injectlateinit 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 nullreturn 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.ktindex 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.SingletonImageLoaderimport coil3.disk.DiskCacheimport coil3.memory.MemoryCacheimport coil3.request.crossfade+import com.streamvault.app.ui.accessibility.isReducedMotionEnabledimport dagger.hilt.android.HiltAndroidAppimport kotlinx.coroutines.Dispatchersimport 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.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/cast/CastModels.kt b/app/src/main/java/com/streamvault/app/cast/CastModels.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/cast/CastRouteChooserActivity.kt b/app/src/main/java/com/streamvault/app/cast/CastRouteChooserActivity.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/cast/StreamVaultCastOptionsProvider.kt b/app/src/main/java/com/streamvault/app/cast/StreamVaultCastOptionsProvider.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt b/app/src/main/java/com/streamvault/app/di/DatabaseModule.ktindex 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.ktindex 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.diimport com.streamvault.data.local.DatabaseTransactionRunnerimport com.streamvault.data.local.RoomDatabaseTransactionRunner+import com.streamvault.data.preferences.PreferencesRepositoryimport com.streamvault.data.repository.*+import com.streamvault.domain.manager.ParentalControlSessionStoreimport com.streamvault.domain.repository.*import dagger.Bindsimport dagger.Module@@ -51,6 +53,9 @@ abstract class RepositoryModule {@Binds @Singletonabstract fun bindRecordingManager(impl: com.streamvault.data.manager.RecordingManagerImpl): com.streamvault.domain.manager.RecordingManager+ @Binds @Singleton+ abstract fun bindParentalControlSessionStore(impl: PreferencesRepository): ParentalControlSessionStore+companion object {@Provides@Singletondiff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.ktindex 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.Uriimport androidx.compose.runtime.Composable+import androidx.compose.runtime.LaunchedEffectimport androidx.lifecycle.Lifecycle+import androidx.lifecycle.compose.collectAsStateWithLifecycleimport androidx.lifecycle.compose.dropUnlessResumedimport androidx.navigation.NavHostControllerimport androidx.navigation.NavOptionsBuilder@@ -25,6 +28,7 @@ import com.streamvault.app.ui.screens.provider.ProviderSetupScreenimport com.streamvault.app.ui.screens.series.SeriesScreenimport com.streamvault.app.ui.screens.settings.SettingsScreenimport com.streamvault.app.ui.screens.welcome.WelcomeScreen+import com.streamvault.app.MainActivityimport 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.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt b/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/tv/WatchNextManager.kt b/app/src/main/java/com/streamvault/app/tv/WatchNextManager.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.kt b/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.kt b/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/ui/accessibility/MotionPreferences.kt b/app/src/main/java/com/streamvault/app/ui/accessibility/MotionPreferences.ktnew file mode 100644index 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 filediff --git a/app/src/main/java/com/streamvault/app/ui/components/AsyncImageModels.kt b/app/src/main/java/com/streamvault/app/ui/components/AsyncImageModels.ktindex 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.componentsimport androidx.compose.runtime.Composableimport androidx.compose.runtime.rememberimport androidx.compose.ui.platform.LocalContext+import com.streamvault.app.ui.accessibility.rememberReducedMotionEnabledimport coil3.request.ImageRequestimport coil3.request.crossfade@Composablefun 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.ktindex 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.widthimport androidx.compose.foundation.shape.RoundedCornerShapeimport androidx.compose.material3.LinearProgressIndicatorimport androidx.compose.runtime.Composable+import androidx.compose.runtime.collectAsStateimport androidx.compose.runtime.getValueimport androidx.compose.runtime.mutableStateOf-import androidx.compose.runtime.produceStateimport androidx.compose.runtime.rememberimport androidx.compose.runtime.setValue+import kotlinx.coroutines.CoroutineScope+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.SupervisorJobimport kotlinx.coroutines.delay+import kotlinx.coroutines.flow.SharingStarted+import kotlinx.coroutines.flow.flow+import kotlinx.coroutines.flow.stateInimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifierimport androidx.compose.ui.draw.clip@@ -33,6 +39,9 @@ import androidx.compose.ui.graphics.Colorimport androidx.compose.ui.graphics.graphicsLayerimport androidx.compose.ui.layout.ContentScaleimport androidx.compose.ui.res.stringResource+import androidx.compose.ui.semantics.contentDescription+import androidx.compose.ui.semantics.semantics+import androidx.compose.ui.semantics.stateDescriptionimport androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.unit.Dpimport androidx.compose.ui.unit.dp@@ -65,6 +74,21 @@ import com.streamvault.domain.model.Movieimport com.streamvault.domain.model.Seriesimport 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()+ )+}+@Composablefun 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 = scalescaleY = 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.smallFocusableCard(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.ktindex 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.focusRequesterimport androidx.compose.ui.focus.onFocusChangedimport androidx.compose.ui.graphics.SolidColorimport androidx.compose.ui.platform.LocalSoftwareKeyboardController+import androidx.compose.ui.semantics.contentDescription+import androidx.compose.ui.semantics.semantics+import androidx.compose.ui.semantics.stateDescriptionimport androidx.compose.ui.text.input.ImeActionimport androidx.compose.ui.unit.dpimport 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.ktindex 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.ModifierNodeElementimport androidx.compose.ui.node.invalidateDrawimport androidx.compose.ui.platform.InspectorInfoimport androidx.compose.ui.unit.dp+import com.streamvault.app.ui.accessibility.rememberReducedMotionEnabledimport kotlinx.coroutines.Jobimport kotlinx.coroutines.isActiveimport 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 thisprivate data class ShimmerElement(private val baseColor: Color@@ -101,10 +103,11 @@ private class ShimmerNode(fun SkeletonCard(modifier: Modifier = Modifier) {val bgColor = MaterialTheme.colorScheme.surfaceVariantval 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.surfaceVariantval 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.ktindex 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.ErrorColorimport com.streamvault.app.ui.theme.FocusBorderimport com.streamvault.app.ui.theme.Primaryimport com.streamvault.app.ui.theme.SurfaceElevated+import com.streamvault.app.ui.design.requestFocusSafelyimport kotlinx.coroutines.delayimport androidx.compose.ui.res.stringResourceimport 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.ktindex 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.MaterialThemeimport androidx.tv.material3.Surfaceimport androidx.tv.material3.SurfaceDefaultsimport androidx.tv.material3.Text+import com.streamvault.app.ui.design.requestFocusSafelyimport com.streamvault.app.ui.design.FocusSpecimport com.streamvault.app.Rimport com.streamvault.app.ui.theme.FocusBorder@@ -59,7 +60,7 @@ fun RenameGroupDialog(val keyboardController = LocalSoftwareKeyboardController.currentLaunchedEffect(Unit) {- runCatching { focusRequester.requestFocus() }+ focusRequester.requestFocusSafely(tag = "RenameGroupDialog", target = "Rename group field")keyboardController?.show()delay(500)canInteract = truediff --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.ktindex 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.TextOverflowimport androidx.compose.ui.unit.Dpimport androidx.compose.ui.unit.dpimport androidx.compose.ui.res.stringResource+import androidx.compose.ui.semantics.contentDescription+import androidx.compose.ui.semantics.semantics+import androidx.compose.ui.semantics.stateDescriptionimport androidx.tv.material3.Borderimport androidx.tv.material3.ClickableSurfaceDefaultsimport 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 = scalescaleY = 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.ktindex 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.Colorimport androidx.compose.ui.graphics.graphicsLayerimport androidx.compose.ui.graphics.vector.ImageVectorimport 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.semanticsimport androidx.compose.ui.text.TextStyleimport androidx.compose.ui.text.style.TextAlignimport 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.largeSurface(- 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.ktindex 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.Logimport androidx.compose.runtime.Composableimport androidx.compose.runtime.DisposableEffectimport androidx.compose.runtime.LaunchedEffect@@ -14,6 +15,18 @@ import androidx.lifecycle.Lifecycleimport androidx.lifecycle.LifecycleEventObserverimport 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+ }+}+@Composablefun 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.ktindex 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.dpobject FocusSpec {const val FocusedScale = 1.06fconst 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.ktindex 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.Colorimport androidx.compose.ui.layout.ContentScaleimport androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.Borderimport androidx.tv.material3.Buttonimport androidx.tv.material3.ButtonDefaultsdiff --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.ktindex 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.ktindex 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.stringResourceimport androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.unit.dpimport androidx.compose.ui.unit.Dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.Borderimport androidx.tv.material3.Buttonimport androidx.tv.material3.ButtonDefaultsdiff --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.ktindex 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.typeimport androidx.compose.ui.res.stringResourceimport androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.Borderimport androidx.tv.material3.ClickableSurfaceDefaultsimport androidx.tv.material3.MaterialThemediff --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.ktindex 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.LazyColumnimport androidx.compose.foundation.lazy.itemsimport androidx.compose.foundation.lazy.rememberLazyListState-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid-import androidx.compose.foundation.lazy.grid.GridCellsimport androidx.compose.foundation.lazy.grid.itemsimport androidx.compose.foundation.borderimport androidx.compose.foundation.background@@ -32,7 +30,7 @@ import androidx.compose.ui.graphics.Colorimport androidx.compose.ui.text.font.FontWeightimport androidx.compose.ui.unit.dpimport androidx.compose.ui.unit.sp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.*import androidx.compose.material3.SnackbarHostimport androidx.compose.material3.SnackbarHostState@@ -52,8 +50,6 @@ import com.streamvault.app.ui.components.dialogs.PremiumDialogimport com.streamvault.app.ui.components.dialogs.PremiumDialogFooterButtonimport com.streamvault.app.ui.components.dialogs.RenameGroupDialogimport com.streamvault.app.ui.components.ReorderTopBar-import com.streamvault.app.ui.components.SkeletonCard-import com.streamvault.app.ui.components.shimmerEffectimport com.streamvault.app.ui.components.shell.AppNavigationChromeimport com.streamvault.app.ui.components.shell.AppScreenScaffoldimport 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 = nullviewModel.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 = multiViewViewModeldiff --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.ktindex 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.homeimport androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScopeimport com.streamvault.app.di.AuxiliaryPlayerEngine+import com.streamvault.app.tvinput.TvInputChannelSyncManagerimport com.streamvault.app.ui.model.LiveTvChannelModeimport com.streamvault.data.preferences.PreferencesRepositoryimport 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,@AuxiliaryPlayerEngineprivate 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 ?: returnviewModelScope.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.ktindex 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.Alignmentimport androidx.compose.ui.Modifierimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.*import androidx.compose.ui.layout.ContentScaleimport coil3.compose.AsyncImagediff --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.ktindex 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.ktindex 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.ktindex 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.collectAsStateWithLifecycleimport androidx.compose.runtime.collectAsStateimport androidx.lifecycle.compose.collectAsStateWithLifecycleimport androidx.compose.runtime.getValue-import androidx.lifecycle.compose.collectAsStateWithLifecycle-import androidx.compose.runtime.mutableStateOf-import androidx.lifecycle.compose.collectAsStateWithLifecycleimport androidx.compose.runtime.remember-import androidx.lifecycle.compose.collectAsStateWithLifecycle-import androidx.compose.runtime.setValueimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifierimport androidx.compose.ui.focus.FocusRequester@@ -36,7 +31,7 @@ import androidx.compose.ui.res.stringResourceimport androidx.compose.ui.text.font.FontWeightimport androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.Borderimport androidx.tv.material3.ClickableSurfaceDefaultsimport androidx.tv.material3.MaterialTheme@@ -62,7 +57,7 @@ fun MultiViewPlannerDialog(val slots by viewModel.slotsFlow.collectAsStateWithLifecycle()val isPickerMode = pendingChannel != nullval 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.ktindex 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.dpimport androidx.compose.ui.unit.spimport androidx.compose.ui.viewinterop.AndroidViewimport androidx.compose.ui.res.stringResource-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.media3.common.util.UnstableApiimport androidx.tv.material3.Borderimport 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.ktindex 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.ktindex 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.PowerManagerimport androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScopeimport com.streamvault.app.di.AuxiliaryPlayerEngine-import com.streamvault.data.remote.xtream.XtreamStreamUrlResolverimport com.streamvault.data.preferences.PreferencesRepositoryimport com.streamvault.domain.model.Channel-import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.repository.ChannelRepositoryimport com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.player.PlayerEngineimport dagger.hilt.android.lifecycle.HiltViewModelimport 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? = nullprivate var runtimeActiveSlotLimit: Int = MultiViewManager.MAX_SLOTS+ private var activeProviderConnectionLimit: Int? = nullprivate var sustainedStressSamples: Int = 0private var stableSamples: Int = 0private var lastPolicyAdjustmentAt: Long = 0Lprivate 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 = ++slotInitVersiontelemetryJob?.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) }+ ?: deviceActiveSlotLimitval 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 audibleapplyFocusAudio(_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? ActivityManagerval memoryClass = activityManager?.memoryClass ?: 256diff --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.ktindex 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.stringResourceimport androidx.lifecycle.Lifecycleimport com.streamvault.app.Rimport com.streamvault.app.MainActivity+import com.streamvault.app.cast.CastConnectionState+import com.streamvault.app.ui.design.requestFocusSafelyimport com.streamvault.app.ui.screens.player.overlay.ChannelInfoOverlayimport com.streamvault.app.ui.screens.player.overlay.CategoryListOverlayimport com.streamvault.app.ui.screens.player.overlay.ChannelListOverlay@@ -89,6 +91,7 @@ import com.streamvault.app.navigation.Routesfun 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 focusdelay(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 actionsif (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 falseif (showChannelListOverlay && contentType == "LIVE") {// Second left press while channel list is open β open category listviewModel.openCategoryListOverlay()@@ -361,6 +384,7 @@ fun PlayerScreen(if (showChannelListOverlay || showEpgOverlay || showChannelInfoOverlay || showDiagnostics) {viewModel.onLiveOverlayInteraction()}+ if (showControls && contentType != "LIVE") return@onKeyEvent falseif (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 falseif (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 falseif (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.ktindex 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.playerimport androidx.lifecycle.ViewModelimport 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.CastStartResultimport com.streamvault.app.di.MainPlayerEngine+import com.streamvault.app.tv.LauncherRecommendationsManager+import com.streamvault.app.tv.WatchNextManagerimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolver+import com.streamvault.data.security.CredentialDecryptionExceptionimport com.streamvault.domain.manager.RecordingManagerimport com.streamvault.domain.model.Categoryimport 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:MainPlayerEngineval 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>? = nullprivate 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 = providerIdcurrentContentId = internalChannelIdcurrentTitle = title+ currentArtworkUrl = artworkUrlcurrentContentType = 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() } ?: currentTitlecurrentStreamUrl = 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 = playbackKeyviewModelScope.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 playercurrentTitle = "${_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() // hidediff --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.ktindex 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.slideInVerticallyimport androidx.compose.animation.slideOutHorizontallyimport androidx.compose.animation.slideOutVerticallyimport androidx.compose.foundation.background-import androidx.compose.foundation.layout.FlowRowimport androidx.compose.foundation.layout.Arrangementimport androidx.compose.foundation.layout.Boximport androidx.compose.foundation.layout.Columnimport androidx.compose.foundation.layout.ExperimentalLayoutApi+import androidx.compose.foundation.layout.FlowRowimport androidx.compose.foundation.layout.Rowimport androidx.compose.foundation.layout.Spacerimport androidx.compose.foundation.layout.fillMaxSize@@ -24,7 +24,6 @@ import androidx.compose.foundation.layout.paddingimport androidx.compose.foundation.layout.sizeimport androidx.compose.foundation.layout.widthimport androidx.compose.foundation.layout.widthIn-import androidx.compose.foundation.layout.paddingFromBaselineimport androidx.compose.foundation.shape.RoundedCornerShapeimport androidx.compose.material.icons.Iconsimport androidx.compose.material.icons.filled.PlayArrow@@ -60,7 +59,6 @@ import androidx.tv.material3.Textimport com.streamvault.app.Rimport com.streamvault.app.ui.screens.player.NumericChannelInputStateimport com.streamvault.app.ui.theme.ErrorColor-import com.streamvault.app.ui.theme.OnSurfaceDimimport com.streamvault.app.ui.theme.Primaryimport com.streamvault.domain.model.Programimport 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+ )}@Composablediff --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.ktindex 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.ktindex 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.KeyEventimport androidx.compose.foundation.backgroundimport androidx.compose.foundation.clickableimport androidx.compose.foundation.layout.Arrangement@@ -16,18 +17,26 @@ import androidx.compose.foundation.lazy.LazyColumnimport androidx.compose.foundation.lazy.itemsimport androidx.compose.foundation.shape.RoundedCornerShapeimport androidx.compose.runtime.Composable+import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.rememberimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifier+import androidx.compose.ui.focus.FocusRequester+import androidx.compose.ui.focus.focusRequesterimport androidx.compose.ui.graphics.Color+import androidx.compose.ui.input.key.onPreviewKeyEventimport androidx.compose.ui.res.stringResourceimport androidx.compose.ui.text.font.FontWeightimport androidx.compose.ui.text.style.TextAlignimport androidx.compose.ui.unit.dp+import androidx.compose.ui.window.Dialog+import androidx.compose.ui.window.DialogPropertiesimport androidx.tv.material3.ClickableSurfaceDefaultsimport androidx.tv.material3.MaterialThemeimport androidx.tv.material3.Surfaceimport androidx.tv.material3.Textimport com.streamvault.app.R+import com.streamvault.app.ui.design.requestFocusSafelyimport com.streamvault.app.ui.screens.player.PlayerNoticeActionimport com.streamvault.app.ui.screens.player.PlayerNoticeStateimport 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 -> audioTracksTrackType.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.ktindex 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.TextAlignimport androidx.compose.ui.text.input.PasswordVisualTransformationimport androidx.compose.ui.text.input.VisualTransformationimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.activity.compose.rememberLauncherForActivityResultimport androidx.activity.result.contract.ActivityResultContractsimport androidx.compose.ui.platform.LocalContextdiff --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.ktindex 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.focusRequesterimport androidx.compose.ui.graphics.Colorimport androidx.compose.ui.platform.LocalFocusManagerimport 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.stateDescriptionimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScopeimport 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)@Composablefun 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.ktindex 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.ContentScaleimport androidx.compose.ui.res.stringResourceimport androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.Borderimport androidx.tv.material3.Buttonimport androidx.tv.material3.ButtonDefaultsdiff --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.ktindex 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.Alignmentimport androidx.compose.ui.Modifierimport androidx.compose.ui.unit.dpimport androidx.compose.foundation.shape.RoundedCornerShape-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.*import androidx.compose.ui.layout.ContentScaleimport coil3.compose.AsyncImagediff --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.ktindex 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.ktindex 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.onFocusChangedimport androidx.compose.ui.text.font.FontWeightimport androidx.compose.ui.platform.LocalUriHandlerimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.tv.material3.*import androidx.compose.material3.SnackbarHostimport androidx.compose.material3.SnackbarHostStatediff --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.ktindex 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.Applicationimport androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScopeimport com.streamvault.app.R+import com.streamvault.app.tvinput.TvInputChannelSyncManagerimport com.streamvault.app.ui.model.LiveTvChannelModeimport com.streamvault.data.preferences.PreferencesRepositoryimport 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.ktindex 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.Colorimport androidx.compose.ui.res.stringResourceimport androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.compose.material.icons.Iconsimport androidx.compose.material.icons.automirrored.filled.ArrowBackimport androidx.compose.foundation.shape.RoundedCornerShapediff --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.ktindex 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.SavedStateHandleimport androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScopeimport com.streamvault.domain.model.Category+import com.streamvault.domain.model.Resultimport com.streamvault.domain.repository.CategoryRepositoryimport dagger.hilt.android.lifecycle.HiltViewModelimport 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.ktindex 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.Brushimport androidx.compose.ui.graphics.Colorimport androidx.compose.ui.res.stringResourceimport androidx.compose.ui.unit.dp-import androidx.hilt.navigation.compose.hiltViewModel+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScopeimport androidx.compose.material3.CircularProgressIndicatordiff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xmlindex 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.xmlindex 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.xmlnew file mode 100644index 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 filediff --git a/app/src/main/res/xml/tv_input_service.xml b/app/src/main/res/xml/tv_input_service.xmlnew file mode 100644index 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 filediff --git a/data/build.gradle.kts b/data/build.gradle.ktsindex 6de9b823..6bab5619 100644--- a/data/build.gradle.kts+++ b/data/build.gradle.kts@@ -66,6 +66,7 @@ dependencies {// DataStoreimplementation(libs.datastore.preferences)+ implementation(libs.security.crypto)// Coreimplementation(libs.core.ktx)diff --git a/data/schemas/com.streamvault.data.local.StreamVaultDatabase/14.json b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/14.jsonnew file mode 100644index 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 filediff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.ktindex 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 filediff --git a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt b/data/src/main/java/com/streamvault/data/local/entity/Entities.ktindex 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.ktindex 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.preferencesimport android.content.Context+import android.content.SharedPreferences+import androidx.security.crypto.EncryptedSharedPreferences+import androidx.security.crypto.MasterKeyimport androidx.datastore.core.DataStoreimport androidx.datastore.preferences.core.Preferencesimport androidx.datastore.preferences.core.booleanPreferencesKey@@ -11,6 +14,8 @@ import androidx.datastore.preferences.core.stringPreferencesKeyimport androidx.datastore.preferences.preferencesDataStoreimport com.streamvault.data.local.dao.ChannelPreferenceDaoimport com.streamvault.data.local.entity.ChannelPreferenceEntity+import com.streamvault.domain.manager.ParentalControlSessionState+import com.streamvault.domain.manager.ParentalControlSessionStoreimport java.security.SecureRandomimport javax.crypto.SecretKeyFactoryimport javax.crypto.spec.PBEKeySpec@@ -31,11 +36,13 @@ private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(naclass PreferencesRepository @Inject constructor(@ApplicationContext private val context: Context,private val channelPreferenceDao: ChannelPreferenceDao-) {+) : ParentalControlSessionStore {companion object {private const val PIN_SALT_BYTES = 16private const val PIN_HASH_ITERATIONS = 120_000private const val PIN_HASH_KEY_BITS = 256+ private const val PIN_MAX_ATTEMPTS = 5+ private const val PIN_LOCKOUT_DURATION_MS = 15 * 60 * 1000Lprivate 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.ktindex 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.IOExceptionimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.withContextimport kotlinx.serialization.json.Json+import kotlinx.serialization.SerializationExceptionimport okhttp3.OkHttpClientimport 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 filediff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamApiExceptions.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamApiExceptions.ktnew file mode 100644index 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 filediff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamErrorFormatter.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamErrorFormatter.ktindex 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.CredentialDecryptionExceptionimport java.security.cert.CertificateExceptionimport javax.net.ssl.SSLPeerUnverifiedExceptioninternal 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.ktindex 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.DatabaseTransactionRunnerimport com.streamvault.data.mapper.toDomainimport com.streamvault.domain.model.Categoryimport com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.Resultimport com.streamvault.domain.repository.CategoryRepositoryimport kotlinx.coroutines.flow.Flowimport 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.ktindex 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.Categoryimport com.streamvault.domain.model.Channelimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.Result+import com.streamvault.domain.model.StreamInfoimport com.streamvault.domain.repository.ChannelRepositoryimport kotlinx.coroutines.flow.Flowimport 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.ktindex 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.LibraryBrowseQueryimport com.streamvault.domain.model.Movieimport com.streamvault.domain.model.PagedResultimport com.streamvault.domain.model.Result+import com.streamvault.domain.model.StreamInfoimport com.streamvault.domain.repository.MovieRepositoryimport kotlinx.coroutines.flow.Flowimport 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.ktindex 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.toDomainimport com.streamvault.data.mapper.toEntityimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.PlaybackHistory+import com.streamvault.domain.model.Resultimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport kotlinx.coroutines.flow.Flowimport 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.ktindex 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.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamProviderimport com.streamvault.data.security.CredentialCrypto+import com.streamvault.data.security.CredentialDecryptionExceptionimport com.streamvault.data.sync.SyncManagerimport com.streamvault.data.util.ProviderInputSanitizerimport 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.ACTIVEdiff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.ktindex 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.ktindex 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.ktnew file mode 100644index 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 filediff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.ktindex 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.MovieEntityimport com.streamvault.data.mapper.toDomainimport com.streamvault.data.mapper.toEntityimport 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.XtreamRequestExceptionimport com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamProviderimport com.streamvault.data.remote.xtream.XtreamUrlFactory@@ -29,10 +33,15 @@ import com.streamvault.domain.repository.EpgRepositoryimport com.streamvault.domain.repository.SyncMetadataRepositoryimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.delay+import kotlinx.coroutines.flow.Flowimport kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.flow.StateFlowimport kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.flow.map+import kotlinx.coroutines.flow.updateimport kotlinx.coroutines.withContext+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLockimport okhttp3.OkHttpClientimport okhttp3.Requestimport 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.Idlesuspend 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 = 0openPlaylistStream(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 trueif (error is IOException) return trueval message = error.message.orEmpty().lowercase()@@ -753,7 +785,7 @@ class SyncManager @Inject constructor(return when (this) {is com.streamvault.domain.model.Result.Success -> datais 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.ktnew file mode 100644index 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 filediff --git a/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt b/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.ktnew file mode 100644index 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 filediff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerConcurrencyTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerConcurrencyTest.ktnew file mode 100644index 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 filediff --git a/docs/audit/04_MISSING_FEATURES_COMPLETENESS.md b/docs/audit/04_MISSING_FEATURES_COMPLETENESS.mdnew file mode 100644index 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.mdnew file mode 100644index 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.ktindex 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.launchimport kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.flow.StateFlowimport kotlinx.coroutines.flow.asStateFlowimport kotlinx.coroutines.flow.map-import kotlinx.coroutines.flow.updateimport javax.inject.Injectimport 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.ktnew file mode 100644index 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 filediff --git a/domain/src/main/java/com/streamvault/domain/repository/CategoryRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/CategoryRepository.ktindex 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.repositoryimport com.streamvault.domain.model.Categoryimport com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.Resultimport kotlinx.coroutines.flow.Flowinterface 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.ktindex 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_000Ldiff --git a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.ktindex 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.ktindex 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.repositoryimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.PlaybackHistory+import com.streamvault.domain.model.Resultimport kotlinx.coroutines.flow.Flowinterface 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.ktindex 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.ktindex 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.Testclass ParentalControlManagerTest {private lateinit var manager: ParentalControlManager+ private lateinit var store: FakeParentalControlSessionStore+ private var baseNow: Long = 0L@Beforefun setup() {- manager = ParentalControlManager()+ store = FakeParentalControlSessionStore()+ manager = ParentalControlManager(store)+ baseNow = System.currentTimeMillis() + 10_000L}@Test@@ -23,52 +27,52 @@ class ParentalControlManagerTest {@Testfun `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()}@Testfun `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()}@Testfun `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()}@Testfun `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()}@Testfun `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()}@Testfun `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 {@Testfun `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.tomlindex 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"# Testjunit = "4.13.2"truth = "1.4.4"@@ -89,11 +95,15 @@ coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutin# DataStoredatastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }+security-crypto = { group = "androidx.security", name = "security-crypto", version.ref = "security-crypto" }# Corecore-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" }# Testjunit = { 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.ktindex 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.absimport okhttp3.OkHttpClientimport javax.inject.Injectimport 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 = trueprivate var pollingJob: Job? = nullprivate var lastStreamInfo: StreamInfo? = nullprivate 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 sourceval 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