Skip to content

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

refactor(settings): extract settings preferences domain contract

David Nashashe1ce9aad71b1
diff --git a/.superpowers/sdd/2026-09-05-settings-data-boundary/task-2-report.md b/.superpowers/sdd/2026-09-05-settings-data-boundary/task-2-report.md
new file mode 100644
index 00000000..7fdb3305
--- /dev/null
+++ b/.superpowers/sdd/2026-09-05-settings-data-boundary/task-2-report.md
@@ -0,0 +1,148 @@
+# Task 2 report: Settings preferences contract
+
+## Status and scope
+
+Implemented Task 2 in `C:\Users\david\.gemini\antigravity\scratch\iptv-player\tmp\phase7-provider-boundary` on 2026-09-05. Read the exact Task 2 brief before implementation. No subagents were dispatched. The initial worktree was clean.
+
+The requested compile/test gate is green. The final supplemental gate is also green, including all 37 settings tests outside the deliberately red Task 1 module-boundary test, compilation of data tests, and the app's Hilt component compilation.
+
+Task 2 is a type extraction: settings consumers now use the domain contract, and the original repository remains the persistence implementation. Tasks 3–4 still own operational dependency migration and removal of the settings `:data` dependency.
+
+## Implementation
+
+- Added `SettingsPreferences` with exactly 176 members referenced by `feature/settings/src/main`: 86 Flow properties, 88 suspend functions, and two ordinary functions returning Flow (`getHiddenCategoryIds` and `getCategorySortMode`).
+- Preserved existing property types, function parameter names, nullability, generic arguments, suspend modifiers, and return types. Existing Boolean/Long-returning commands retain their return types. The contract has no DataStore/Room types or untyped command map.
+- Moved `DatabaseMaintenanceSnapshot` to `com.streamvault.domain.settings`, preserving all 17 fields, their order and types, and the absence of constructor defaults. Updated every affected Kotlin source/test import across the repository.
+- Made `PreferencesRepository` implement `SettingsPreferences`, adding 175 new `override` modifiers; `verifyParentalPin` already had one through `ParentalPinVerifier`. Existing parental interfaces remain implemented.
+- Migrated all eight settings production files consuming `PreferencesRepository`, including fully qualified helper parameter types, and all three existing settings test consumers. Existing test assertions were preserved.
+- Added a fake-backed contract test that passes an interface-typed preference value into the real `SettingsAppUpdateActions` constructor and `observeCategoryManagement` helper. The tests also verify failed-update state/persistence and hidden-category derivation.
+- Added the interface's Hilt binding in the existing app `RepositoryModule`. This small supporting change is required because settings view models now inject the interface; it resolves to the same singleton repository. It does not introduce the Task 3 operations module or change persistence.
+
+## Files
+
+- `domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.kt`
+- `domain/src/main/java/com/streamvault/domain/settings/DatabaseMaintenanceSnapshot.kt`
+- `data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt`
+- `app/src/main/java/com/streamvault/app/di/RepositoryModule.kt`
+- `data/src/main/java/com/streamvault/data/sync/SyncWorker.kt`
+- `data/src/test/java/com/streamvault/data/sync/SyncWorkerPolicyTest.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModel.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActions.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDerivedStateObservers.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsGuideDefaultCategoryBindings.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsObserverRegistrations.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsOperationalModels.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsProviderActions.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsStateBindings.kt`
+- `feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsViewModel.kt`
+- `feature/settings/src/test/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModelTest.kt`
+- `feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActionsTest.kt`
+- `feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsProviderActionsTest.kt`
+- `feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsPreferencesContractTest.kt`
+- `.superpowers/sdd/2026-09-05-settings-data-boundary/task-2-report.md` (this report).
+
+All listed source changes belong to Task 2. Generated graph files and raw command logs remain local ignored artifacts.
+
+## TDD: RED before implementation
+
+First added only `SettingsPreferencesContractTest.kt`; production code had not been changed.
+
+Environment setup used for all Gradle commands:
+
+```powershell
+$env:ANDROID_HOME = Split-Path (Split-Path (Get-Command adb).Source)
+```
+
+`adb` resolved to `E:\androidSdk\platform-tools\adb.exe`, so `ANDROID_HOME` was `E:\androidSdk`. No local SDK configuration file was changed.
+
+Ran:
+
+```powershell
+./gradlew.bat :feature:settings:compileDebugUnitTestKotlin --console=plain
+```
+
+Result: expected RED, exit 1, `BUILD FAILED in 14s`; 52 actionable tasks (3 executed, 1 from cache, 48 up-to-date).
+
+The compiler reached the new test and reported:
+- Unresolved domain `settings` package / `SettingsPreferences` import.
+- `Unresolved reference 'SettingsPreferences'` on the interface-typed values and fake.
+- The fake's five overrides reported `overrides nothing`.
+
+This is the requested missing-contract failure, not an SDK or unrelated build failure. The test exercises two real settings entry points: restoring either parameter type to the concrete repository would make its interface-typed argument fail compilation.
+
+Raw log: `task-2-red.log`, beside this report.
+
+## GREEN: required gate
+
+After extracting the contract, moving the snapshot, and changing consumer types, ran exactly the required tasks:
+
+```powershell
+./gradlew.bat :domain:test :data:compileDebugKotlin :feature:settings:compileDebugKotlin :feature:settings:compileDebugUnitTestKotlin --console=plain
+```
+
+Result: exit 0, `BUILD SUCCESSFUL in 1m 32s`; 55 actionable tasks (21 executed, 34 up-to-date). No contract-shape compilation errors occurred. Domain XML results: 145 tests, zero failures/errors/skips.
+
+Raw log: `task-2-green.log`.
+
+## Supplemental verification and the existing boundary RED
+
+Ran the broader check:
+
+```powershell
+./gradlew.bat :feature:settings:testDebugUnitTest :data:compileDebugUnitTestKotlin :app:hiltJavaCompileDebug -x :feature:settings:verifyFeatureSettingsBoundary --console=plain
+```
+
+Result: exit 1, `BUILD FAILED in 1m 11s`; 38 settings tests completed, 37 passed and one failed. The sole failure was the unchanged Task 1 `SettingsModuleBoundaryTest.settingsModuleDeclaresExpectedBoundary`, line 16: settings still declares `project(":data")`. Both new contract tests and all migrated settings tests passed. Data unit-test compilation completed. The app Hilt check had not completed when this invocation stopped.
+
+The Gradle boundary task was explicitly excluded to reach unit tests; the unit-level boundary assertion still demonstrated the expected red state. The Task 1 report and task ledger explicitly defer removing the production dependency and enabling the final policy until Tasks 3–4. Neither boundary test nor build policy was modified.
+
+Raw log: `task-2-supplemental.log`.
+
+## Final verification
+
+Ran:
+
+```powershell
+./gradlew.bat :domain:test :data:compileDebugKotlin :feature:settings:compileDebugKotlin :feature:settings:compileDebugUnitTestKotlin :feature:settings:testDebugUnitTest --tests 'com.streamvault.feature.settings.presentation.*' --tests 'com.streamvault.feature.settings.parental.*' --tests 'com.streamvault.feature.settings.navigation.*' :data:compileDebugUnitTestKotlin :app:hiltJavaCompileDebug -x :feature:settings:verifyFeatureSettingsBoundary --console=plain
+```
+
+Result: exit 0, `BUILD SUCCESSFUL in 22s`; 185 actionable tasks (5 executed, 180 up-to-date). Final settings XML results: 37 tests, zero failures/errors/skips, including both contract tests. These filters include every existing settings test except the known Task 1 root-package module-boundary test. The domain gate remained green with its 145-test result up-to-date.
+
+The app Kotlin/Java compilation and `:app:hiltJavaCompileDebug` completed successfully, validating the new binding and affected production constructor call sites. `:data:compileDebugUnitTestKotlin` passed, covering the moved snapshot's data test import.
+
+Raw log: `task-2-final-verification.log`.
+
+Additional checks:
+
+```powershell
+git -c core.safecrlf=false diff --check
+rg -n 'PreferencesRepository|com.streamvault.data.preferences' feature/settings/src/main feature/settings/src/test -g '*.kt'
+rg -n 'com.streamvault.data.preferences.DatabaseMaintenanceSnapshot' --glob '*.kt' --glob '!tmp/**'
+graphify update .
+```
+
+- Diff whitespace check: exit 0. Removed the empty trailing line left by moving the snapshot before the final check.
+- Both obsolete preference/snapshot reference searches: no matches (normal `rg` exit 1).
+- Enumerated actual settings preference member references and compared against the extracted signature inventory: exactly 176 distinct members; no extra convenience APIs.
+- Compared the repository before/after in memory, normalizing CRLF and undoing only the new imports/interface/override modifiers and snapshot move: identical content. This verifies that all method bodies, property initializers, preference keys/defaults/encodings, and persistence logic remain unchanged.
+- Compared all 14 pre-existing affected consumer/import files to their original versions with only the specified type/import replacements applied: every comparison passed.
+- `graphify update .` ran after source changes and again after the final binding/test annotation change: exit 0. Final graph: 1,328 files, 13,968 nodes, 24,519 edges, 479 communities. `graph.json` and `GRAPH_REPORT.md` refreshed locally. HTML visualization was skipped by graphify because node count exceeds its 5,000-node limit. Raw log: `task-2-graphify.log`.
+
+## Self-review
+
+Used the TDD and verification-before-completion skill workflows, with the user's exact compile-time RED requirement taking precedence over generic runtime-test guidance. Performed review locally without subagents.
+
+- The interface exposes only settings-used members, including the two provider-scoped Flow methods and typed setters that return values.
+- Existing repository behavior is mechanically unchanged, as confirmed by the normalized source comparison.
+- The moved snapshot retains its full immutable data shape. Both worker persistence callbacks and settings UI conversion retain their original code.
+- Existing tests now mock the interface without dropping assertions. The new partial fake delegates unused contract members to an interface mock while recording the exercised writes and supplying actual flows.
+- Constructor/helper compilation protects the intended domain boundary. Runtime assertions exercise actual update-action and category-observer behavior.
+- Hilt still supplies the existing singleton repository, and generated component compilation is green.
+- No preference migration, provider/sync behavior change, production dependency enforcement change, or unrelated code cleanup was included.
+
+## Concerns and limitations
+
+- Known, intentional checkpoint concern: the full unfiltered settings suite remains red only on the Task 1 module-boundary assertion until Tasks 3–4 remove `:data` and remaining DAO/entity/sync references. This report does not claim that the complete Phase 7 boundary is finished.
+- Existing Kotlin warnings (annotation targets, unchecked casts, coroutine opt-ins, and duplicate module-name flag) and the JVM class-sharing warning appeared during compilation/tests. They did not fail the requested/final gates.
+- No emulator playback validation or APK assemble/install was performed; no playback behavior was changed. The app was verified through Kotlin/Java/Hilt compilation.
+- No additional Task 2 implementation concerns found. Avoid adding another `SettingsPreferences` binding in Task 3: this task already binds it in the app's `RepositoryModule`.
diff --git a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
index 7c87c610..64b19f8a 100644
--- a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
+++ b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
@@ -31,6 +31,7 @@ import com.streamvault.domain.manager.BackupRestoreStatusStore
import com.streamvault.data.manager.BackupRestoreStatusStoreImpl
import com.streamvault.domain.provider.ProviderCapabilityRegistry
import com.streamvault.domain.provider.ProviderSourceRegistry
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.app.plugins.StreamVaultPluginManager
import dagger.Binds
import dagger.Module
@@ -123,6 +124,9 @@ abstract class RepositoryModule {
@Binds @Singleton
abstract fun bindParentalPinVerifier(impl: PreferencesRepository): ParentalPinVerifier
+ @Binds @Singleton
+ abstract fun bindSettingsPreferences(impl: PreferencesRepository): SettingsPreferences
+
@Binds @Singleton
abstract fun bindProviderSetupInputValidator(impl: ProviderSetupInputValidatorImpl): ProviderSetupInputValidator
diff --git a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
index 9a8d1a80..5c2fa6ac 100644
--- a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
+++ b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
@@ -19,6 +19,8 @@ import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStoreFile
import com.streamvault.data.local.dao.ChannelPreferenceDao
import com.streamvault.data.local.dao.SearchHistoryDao
+import com.streamvault.domain.settings.DatabaseMaintenanceSnapshot
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.domain.model.GroupedChannelLabelMode
import com.streamvault.domain.model.AudioOutputPreference
import com.streamvault.domain.model.ChannelNumberingMode
@@ -150,7 +152,7 @@ class PreferencesRepository @Inject constructor(
private val channelPreferenceDao: ChannelPreferenceDao,
private val searchHistoryDao: SearchHistoryDao,
private val corruptionRecovery: PreferencesCorruptionRecovery
-) : ParentalControlSessionStore, ParentalPinVerifier {
+) : ParentalControlSessionStore, ParentalPinVerifier, SettingsPreferences {
private val preferencesDataStore: DataStore<Preferences> by lazy {
PreferenceDataStoreFactory.create(
corruptionHandler = ReplaceFileCorruptionHandler { cause ->
@@ -369,15 +371,15 @@ class PreferencesRepository @Inject constructor(
preferences[PreferencesKeys.DEFAULT_VIEW_MODE]
}
- val isIncognitoMode: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val isIncognitoMode: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.IS_INCOGNITO_MODE] ?: false
}
- val useXtreamTextClassification: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val useXtreamTextClassification: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.XTREAM_TEXT_CLASSIFICATION] ?: true // default ON
}
- val xtreamBase64TextCompatibility: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val xtreamBase64TextCompatibility: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.XTREAM_BASE64_TEXT_COMPATIBILITY] ?: false
}
@@ -389,45 +391,45 @@ class PreferencesRepository @Inject constructor(
preferences[PreferencesKeys.PLAYER_MUTED] ?: false
}
- val playerMediaSessionEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val playerMediaSessionEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_MEDIA_SESSION_ENABLED] ?: true
}
- val playerFastRetryOnTransientFailures: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val playerFastRetryOnTransientFailures: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_FAST_RETRY_ON_TRANSIENT_FAILURES] ?: false
}
- val playerAudioDecoderMode: Flow<DecoderMode> = context.dataStore.data.map { preferences ->
+ override val playerAudioDecoderMode: Flow<DecoderMode> = context.dataStore.data.map { preferences ->
parseDecoderModePreference(
saved = preferences[PreferencesKeys.PLAYER_AUDIO_DECODER_MODE],
legacySaved = preferences[PreferencesKeys.PLAYER_DECODER_MODE]
)
}
- val playerVideoDecoderMode: Flow<DecoderMode> = context.dataStore.data.map { preferences ->
+ override val playerVideoDecoderMode: Flow<DecoderMode> = context.dataStore.data.map { preferences ->
parseDecoderModePreference(
saved = preferences[PreferencesKeys.PLAYER_VIDEO_DECODER_MODE],
legacySaved = preferences[PreferencesKeys.PLAYER_DECODER_MODE]
)
}
- val playerPlaybackBufferMode: Flow<PlaybackBufferMode> = context.dataStore.data.map { preferences ->
+ override val playerPlaybackBufferMode: Flow<PlaybackBufferMode> = context.dataStore.data.map { preferences ->
parsePlaybackBufferModePreference(preferences[PreferencesKeys.PLAYER_PLAYBACK_BUFFER_MODE])
}
- val playerSurfaceMode: Flow<PlayerSurfaceMode> = context.dataStore.data.map { preferences ->
+ override val playerSurfaceMode: Flow<PlayerSurfaceMode> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_SURFACE_MODE]
?.let { saved -> PlayerSurfaceMode.entries.firstOrNull { it.name == saved } }
?: PlayerSurfaceMode.AUTO
}
- val playerLiveStreamFormatMode: Flow<LiveStreamFormatMode> = context.dataStore.data.map { preferences ->
+ override val playerLiveStreamFormatMode: Flow<LiveStreamFormatMode> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_LIVE_STREAM_FORMAT_MODE]
?.let { saved -> LiveStreamFormatMode.entries.firstOrNull { it.name == saved } }
?: LiveStreamFormatMode.AUTO
}
- val playerVodHttpProtocolMode: Flow<VodHttpProtocolMode> = context.dataStore.data.map { preferences ->
+ override val playerVodHttpProtocolMode: Flow<VodHttpProtocolMode> = context.dataStore.data.map { preferences ->
(
preferences[PreferencesKeys.PLAYER_VOD_HTTP_PROTOCOL_MODE]
?: preferences[PreferencesKeys.LEGACY_PLAYER_MOVIE_HTTP_PROTOCOL_MODE]
@@ -436,100 +438,100 @@ class PreferencesRepository @Inject constructor(
?: VodHttpProtocolMode.COMPATIBILITY_HTTP1
}
- val playerAudioOutputPreference: Flow<AudioOutputPreference> = context.dataStore.data.map { preferences ->
+ override val playerAudioOutputPreference: Flow<AudioOutputPreference> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_AUDIO_OUTPUT_PREFERENCE]
?.let { saved -> AudioOutputPreference.entries.firstOrNull { it.name == saved } }
?: AudioOutputPreference.AUTO
}
- val playerCompatibilityMemoryEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val playerCompatibilityMemoryEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_COMPATIBILITY_MEMORY_ENABLED] ?: true
}
- val playerPlaybackSpeed: Flow<Float> = context.dataStore.data.map { preferences ->
+ override val playerPlaybackSpeed: Flow<Float> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_PLAYBACK_SPEED]
?.toFloatOrNull()
?.coerceIn(0.5f, 2f)
?: 1f
}
- val playerExternalPlaybackMode: Flow<com.streamvault.domain.model.ExternalPlaybackMode> = context.dataStore.data.map { preferences ->
+ override val playerExternalPlaybackMode: Flow<com.streamvault.domain.model.ExternalPlaybackMode> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_EXTERNAL_PLAYBACK_MODE]
?.let { saved -> com.streamvault.domain.model.ExternalPlaybackMode.fromStorageValue(saved) }
?: com.streamvault.domain.model.ExternalPlaybackMode.INTERNAL_PLAYER
}
- val playerAudioVideoOffsetMs: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerAudioVideoOffsetMs: Flow<Int> = context.dataStore.data.map { preferences ->
(preferences[PreferencesKeys.PLAYER_AUDIO_VIDEO_OFFSET_MS] ?: 0)
.coerceIn(AUDIO_VIDEO_OFFSET_MIN_MS, AUDIO_VIDEO_OFFSET_MAX_MS)
}
- val playerAudioVideoSyncEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val playerAudioVideoSyncEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_AUDIO_VIDEO_SYNC_ENABLED] ?: false
}
- val preferredAudioLanguage: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val preferredAudioLanguage: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PREFERRED_AUDIO_LANGUAGE]
?.trim()
?.takeIf { it.isNotBlank() }
?: "auto"
}
- val playerSubtitleTextScale: Flow<Float> = context.dataStore.data.map { preferences ->
+ override val playerSubtitleTextScale: Flow<Float> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_SUBTITLE_TEXT_SCALE]
?.toFloatOrNull()
?.coerceIn(0.75f, 1.75f)
?: 1f
}
- val playerSubtitleTextColor: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerSubtitleTextColor: Flow<Int> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_SUBTITLE_TEXT_COLOR] ?: 0xFFFFFFFF.toInt()
}
- val playerSubtitleBackgroundColor: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerSubtitleBackgroundColor: Flow<Int> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_SUBTITLE_BACKGROUND_COLOR] ?: 0x80000000.toInt()
}
- val playerLiveTranslationEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val playerLiveTranslationEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_LIVE_TRANSLATION_ENABLED] ?: false
}
- val playerLiveTranslationEndpoint: Flow<String> = context.dataStore.data.map { preferences ->
+ override val playerLiveTranslationEndpoint: Flow<String> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_LIVE_TRANSLATION_ENDPOINT]
?.trim()
?.takeIf { it.isNotBlank() }
?: "http://10.0.2.2:8765"
}
- val playerControlsTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerControlsTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
(preferences[PreferencesKeys.PLAYER_CONTROLS_TIMEOUT_SECONDS] ?: 5).coerceIn(2, 60)
}
- val playerLiveOverlayTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerLiveOverlayTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
(preferences[PreferencesKeys.PLAYER_LIVE_OVERLAY_TIMEOUT_SECONDS] ?: 4).coerceIn(2, 60)
}
- val playerNoticeTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerNoticeTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
(preferences[PreferencesKeys.PLAYER_NOTICE_TIMEOUT_SECONDS] ?: 6).coerceIn(2, 60)
}
- val playerDiagnosticsTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerDiagnosticsTimeoutSeconds: Flow<Int> = context.dataStore.data.map { preferences ->
(preferences[PreferencesKeys.PLAYER_DIAGNOSTICS_TIMEOUT_SECONDS] ?: 15).coerceIn(2, 60)
}
- val playerWifiMaxVideoHeight: Flow<Int?> = context.dataStore.data.map { preferences ->
+ override val playerWifiMaxVideoHeight: Flow<Int?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_WIFI_MAX_VIDEO_HEIGHT]?.takeIf { it > 0 }
}
- val playerEthernetMaxVideoHeight: Flow<Int?> = context.dataStore.data.map { preferences ->
+ override val playerEthernetMaxVideoHeight: Flow<Int?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_ETHERNET_MAX_VIDEO_HEIGHT]?.takeIf { it > 0 }
}
- val playerTimeshiftEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val playerTimeshiftEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_TIMESHIFT_ENABLED] ?: false
}
- val playerTimeshiftDepthMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val playerTimeshiftDepthMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
when (preferences[PreferencesKeys.PLAYER_TIMESHIFT_DEPTH_MINUTES] ?: 30) {
15, 30, 60 -> preferences[PreferencesKeys.PLAYER_TIMESHIFT_DEPTH_MINUTES] ?: 30
in Int.MIN_VALUE..22 -> 15
@@ -538,41 +540,41 @@ class PreferencesRepository @Inject constructor(
}
}
- val playerTimeshiftBackend: Flow<TimeshiftBackendPreference> = context.dataStore.data.map { preferences ->
+ override val playerTimeshiftBackend: Flow<TimeshiftBackendPreference> = context.dataStore.data.map { preferences ->
parseTimeshiftBackendPreference(preferences[PreferencesKeys.PLAYER_TIMESHIFT_BACKEND])
}
- val defaultStopPlaybackTimerMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val defaultStopPlaybackTimerMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
sanitizePlaybackTimerMinutes(preferences[PreferencesKeys.DEFAULT_STOP_PLAYBACK_TIMER_MINUTES] ?: 0)
}
- val defaultIdleStandbyTimerMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val defaultIdleStandbyTimerMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
sanitizePlaybackTimerMinutes(preferences[PreferencesKeys.DEFAULT_IDLE_STANDBY_TIMER_MINUTES] ?: 0)
}
- val lastSpeedTestMegabits: Flow<Double?> = context.dataStore.data.map { preferences ->
+ override val lastSpeedTestMegabits: Flow<Double?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_SPEED_TEST_MEGABITS]?.toDoubleOrNull()
}
- val lastSpeedTestTimestamp: Flow<Long?> = context.dataStore.data.map { preferences ->
+ override val lastSpeedTestTimestamp: Flow<Long?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_SPEED_TEST_TIMESTAMP]?.takeIf { it > 0L }
}
- val lastSpeedTestTransport: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val lastSpeedTestTransport: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_SPEED_TEST_TRANSPORT]?.takeIf { it.isNotBlank() }
}
- val lastSpeedTestRecommendedHeight: Flow<Int?> = context.dataStore.data.map { preferences ->
+ override val lastSpeedTestRecommendedHeight: Flow<Int?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_SPEED_TEST_RECOMMENDED_HEIGHT]?.takeIf { it > 0 }
}
- val lastSpeedTestEstimated: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val lastSpeedTestEstimated: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_SPEED_TEST_ESTIMATED] ?: false
}
val recentSearchQueries: Flow<List<String>> = getRecentSearchQueries(SearchHistoryScope.ALL, null)
- val parentalControlLevel: Flow<Int> = context.dataStore.data
+ override val parentalControlLevel: Flow<Int> = context.dataStore.data
.map { preferences ->
val stored = preferences[PreferencesKeys.PARENTAL_CONTROL_LEVEL] ?: 2 // Default to 2 = PRIVATE
// Migration: users who had the old HIDDEN level (stored as 2) are promoted to the new
@@ -582,9 +584,9 @@ class PreferencesRepository @Inject constructor(
if (!migrated && stored == 2) 3 else stored
}
- val hasParentalPin: Flow<Boolean> = context.dataStore.data.map(::hasStoredParentalPin)
+ override val hasParentalPin: Flow<Boolean> = context.dataStore.data.map(::hasStoredParentalPin)
- suspend fun setLastActiveProviderId(id: Long) {
+ override suspend fun setLastActiveProviderId(id: Long) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.LAST_ACTIVE_PROVIDER_ID] = id
}
@@ -616,32 +618,32 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setParentalControlLevel(level: Int) {
+ override suspend fun setParentalControlLevel(level: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PARENTAL_CONTROL_LEVEL] = level
preferences[PreferencesKeys.PARENTAL_V2_MIGRATED] = true
}
}
- suspend fun setIncognitoMode(enabled: Boolean) {
+ override suspend fun setIncognitoMode(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.IS_INCOGNITO_MODE] = enabled
}
}
- suspend fun setUseXtreamTextClassification(enabled: Boolean) {
+ override suspend fun setUseXtreamTextClassification(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.XTREAM_TEXT_CLASSIFICATION] = enabled
}
}
- suspend fun setXtreamBase64TextCompatibility(enabled: Boolean) {
+ override suspend fun setXtreamBase64TextCompatibility(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.XTREAM_BASE64_TEXT_COMPATIBILITY] = enabled
}
}
- suspend fun bumpXtreamTextImportGeneration(): Long {
+ override suspend fun bumpXtreamTextImportGeneration(): Long {
var nextGeneration = 0L
context.dataStore.edit { preferences ->
nextGeneration = (preferences[PreferencesKeys.XTREAM_TEXT_IMPORT_GENERATION] ?: 0L) + 1L
@@ -650,16 +652,16 @@ class PreferencesRepository @Inject constructor(
return nextGeneration
}
- suspend fun getXtreamTextImportGeneration(): Long {
+ override suspend fun getXtreamTextImportGeneration(): Long {
return xtreamTextImportGeneration.first()
}
- suspend fun getXtreamTextImportAppliedGeneration(providerId: Long): Long {
+ override suspend fun getXtreamTextImportAppliedGeneration(providerId: Long): Long {
val key = longPreferencesKey(xtreamTextImportAppliedGenerationKey(providerId))
return context.dataStore.data.first()[key] ?: 0L
}
- suspend fun markXtreamTextImportApplied(providerId: Long, generation: Long) {
+ override suspend fun markXtreamTextImportApplied(providerId: Long, generation: Long) {
val key = longPreferencesKey(xtreamTextImportAppliedGenerationKey(providerId))
context.dataStore.edit { preferences ->
if (generation <= 0L) {
@@ -670,23 +672,23 @@ class PreferencesRepository @Inject constructor(
}
}
- val preventStandbyDuringPlayback: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val preventStandbyDuringPlayback: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PREVENT_STANDBY_DURING_PLAYBACK] ?: true
}
- val autoPlayNextEpisode: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val autoPlayNextEpisode: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.AUTO_PLAY_NEXT_EPISODE] ?: true
}
- val autoCheckAppUpdates: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val autoCheckAppUpdates: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.AUTO_CHECK_APP_UPDATES] ?: true
}
- val autoDownloadAppUpdates: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val autoDownloadAppUpdates: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.AUTO_DOWNLOAD_APP_UPDATES] ?: false
}
- val lastAppUpdateCheckTimestamp: Flow<Long?> = context.dataStore.data.map { preferences ->
+ override val lastAppUpdateCheckTimestamp: Flow<Long?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_APP_UPDATE_CHECK_TIMESTAMP]?.takeIf { it > 0L }
}
@@ -694,7 +696,7 @@ class PreferencesRepository @Inject constructor(
preferences[PreferencesKeys.LAST_APP_UPDATE_ATTEMPT_TIMESTAMP]?.takeIf { it > 0L }
}
- val lastAppUpdateFailureTimestamp: Flow<Long?> = context.dataStore.data.map { preferences ->
+ override val lastAppUpdateFailureTimestamp: Flow<Long?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LAST_APP_UPDATE_FAILURE_TIMESTAMP]?.takeIf { it > 0L }
}
@@ -714,35 +716,35 @@ class PreferencesRepository @Inject constructor(
preferences[PreferencesKeys.APP_UPDATE_DOWNLOADED_VERSION_NAME]?.takeIf { it.isNotBlank() }
}
- val cachedAppUpdateVersionName: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val cachedAppUpdateVersionName: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_UPDATE_LATEST_VERSION_NAME]?.takeIf { it.isNotBlank() }
}
- val cachedAppUpdateVersionCode: Flow<Int?> = context.dataStore.data.map { preferences ->
+ override val cachedAppUpdateVersionCode: Flow<Int?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_UPDATE_LATEST_VERSION_CODE]
}
- val cachedAppUpdateReleaseUrl: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val cachedAppUpdateReleaseUrl: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_UPDATE_RELEASE_URL]?.takeIf { it.isNotBlank() }
}
- val cachedAppUpdateDownloadUrl: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val cachedAppUpdateDownloadUrl: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_UPDATE_DOWNLOAD_URL]?.takeIf { it.isNotBlank() }
}
- val cachedAppUpdateDownloadSha256: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val cachedAppUpdateDownloadSha256: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_UPDATE_DOWNLOAD_SHA256]?.takeIf { it.isNotBlank() }
}
- val cachedAppUpdateReleaseNotes: Flow<String> = context.dataStore.data.map { preferences ->
+ override val cachedAppUpdateReleaseNotes: Flow<String> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_UPDATE_RELEASE_NOTES].orEmpty()
}
- val cachedAppUpdatePublishedAt: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val cachedAppUpdatePublishedAt: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_UPDATE_PUBLISHED_AT]?.takeIf { it.isNotBlank() }
}
- val lastMaintenanceSnapshot: Flow<DatabaseMaintenanceSnapshot?> = context.dataStore.data.map { preferences ->
+ override val lastMaintenanceSnapshot: Flow<DatabaseMaintenanceSnapshot?> = context.dataStore.data.map { preferences ->
val ranAt = preferences[PreferencesKeys.LAST_MAINTENANCE_AT] ?: return@map null
DatabaseMaintenanceSnapshot(
ranAt = ranAt,
@@ -765,19 +767,19 @@ class PreferencesRepository @Inject constructor(
)
}
- val zapAutoRevert: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val zapAutoRevert: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.ZAP_AUTO_REVERT] ?: true
}
- val recordingWifiOnly: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val recordingWifiOnly: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.RECORDING_WIFI_ONLY] ?: false
}
- val recordingPaddingBeforeMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val recordingPaddingBeforeMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
(preferences[PreferencesKeys.RECORDING_PADDING_BEFORE_MINUTES] ?: 0).coerceIn(0, 30)
}
- val recordingPaddingAfterMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
+ override val recordingPaddingAfterMinutes: Flow<Int> = context.dataStore.data.map { preferences ->
(preferences[PreferencesKeys.RECORDING_PADDING_AFTER_MINUTES] ?: 0).coerceIn(0, 30)
}
@@ -791,25 +793,25 @@ class PreferencesRepository @Inject constructor(
(preferences[PreferencesKeys.MAX_CONCURRENT_STREAMS] ?: 2).coerceIn(1, 4)
}
- suspend fun setZapAutoRevert(enabled: Boolean) {
+ override suspend fun setZapAutoRevert(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.ZAP_AUTO_REVERT] = enabled
}
}
- suspend fun setRecordingWifiOnly(enabled: Boolean) {
+ override suspend fun setRecordingWifiOnly(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.RECORDING_WIFI_ONLY] = enabled
}
}
- suspend fun setRecordingPaddingBeforeMinutes(minutes: Int) {
+ override suspend fun setRecordingPaddingBeforeMinutes(minutes: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.RECORDING_PADDING_BEFORE_MINUTES] = minutes.coerceIn(0, 30)
}
}
- suspend fun setRecordingPaddingAfterMinutes(minutes: Int) {
+ override suspend fun setRecordingPaddingAfterMinutes(minutes: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.RECORDING_PADDING_AFTER_MINUTES] = minutes.coerceIn(0, 30)
}
@@ -832,31 +834,31 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setPreventStandbyDuringPlayback(prevent: Boolean) {
+ override suspend fun setPreventStandbyDuringPlayback(prevent: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PREVENT_STANDBY_DURING_PLAYBACK] = prevent
}
}
- suspend fun setAutoPlayNextEpisode(enabled: Boolean) {
+ override suspend fun setAutoPlayNextEpisode(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.AUTO_PLAY_NEXT_EPISODE] = enabled
}
}
- suspend fun setAutoCheckAppUpdates(enabled: Boolean) {
+ override suspend fun setAutoCheckAppUpdates(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.AUTO_CHECK_APP_UPDATES] = enabled
}
}
- suspend fun setAutoDownloadAppUpdates(enabled: Boolean) {
+ override suspend fun setAutoDownloadAppUpdates(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.AUTO_DOWNLOAD_APP_UPDATES] = enabled
}
}
- suspend fun setLastAppUpdateCheckTimestamp(timestampMs: Long?) {
+ override suspend fun setLastAppUpdateCheckTimestamp(timestampMs: Long?) {
context.dataStore.edit { preferences ->
if (timestampMs == null || timestampMs <= 0L) {
preferences.remove(PreferencesKeys.LAST_APP_UPDATE_CHECK_TIMESTAMP)
@@ -866,7 +868,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setLastAppUpdateFailureTimestamp(timestampMs: Long?) {
+ override suspend fun setLastAppUpdateFailureTimestamp(timestampMs: Long?) {
context.dataStore.edit { preferences ->
if (timestampMs == null || timestampMs <= 0L) {
preferences.remove(PreferencesKeys.LAST_APP_UPDATE_FAILURE_TIMESTAMP)
@@ -876,7 +878,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setLastAppUpdateAttemptTimestamp(timestampMs: Long?) {
+ override suspend fun setLastAppUpdateAttemptTimestamp(timestampMs: Long?) {
context.dataStore.edit { preferences ->
if (timestampMs == null || timestampMs <= 0L) {
preferences.remove(PreferencesKeys.LAST_APP_UPDATE_ATTEMPT_TIMESTAMP)
@@ -886,7 +888,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setLastAppUpdateOutcome(outcome: String?) {
+ override suspend fun setLastAppUpdateOutcome(outcome: String?) {
context.dataStore.edit { preferences ->
if (outcome.isNullOrBlank()) {
preferences.remove(PreferencesKeys.LAST_APP_UPDATE_OUTCOME)
@@ -926,7 +928,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setCachedAppUpdateRelease(
+ override suspend fun setCachedAppUpdateRelease(
versionName: String?,
versionCode: Int?,
releaseUrl: String?,
@@ -1024,93 +1026,93 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setPlayerMediaSessionEnabled(enabled: Boolean) {
+ override suspend fun setPlayerMediaSessionEnabled(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_MEDIA_SESSION_ENABLED] = enabled
}
}
- suspend fun setPlayerFastRetryOnTransientFailures(enabled: Boolean) {
+ override suspend fun setPlayerFastRetryOnTransientFailures(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_FAST_RETRY_ON_TRANSIENT_FAILURES] = enabled
}
}
- suspend fun setPlayerAudioDecoderMode(mode: DecoderMode) {
+ override suspend fun setPlayerAudioDecoderMode(mode: DecoderMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_AUDIO_DECODER_MODE] = mode.name
}
}
- suspend fun setPlayerVideoDecoderMode(mode: DecoderMode) {
+ override suspend fun setPlayerVideoDecoderMode(mode: DecoderMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_VIDEO_DECODER_MODE] = mode.name
}
}
- suspend fun setPlayerPlaybackBufferMode(mode: PlaybackBufferMode) {
+ override suspend fun setPlayerPlaybackBufferMode(mode: PlaybackBufferMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_PLAYBACK_BUFFER_MODE] = mode.name
}
}
- suspend fun setPlayerAudioOutputPreference(preference: AudioOutputPreference) {
+ override suspend fun setPlayerAudioOutputPreference(preference: AudioOutputPreference) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_AUDIO_OUTPUT_PREFERENCE] = preference.name
}
}
- suspend fun setPlayerCompatibilityMemoryEnabled(enabled: Boolean) {
+ override suspend fun setPlayerCompatibilityMemoryEnabled(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_COMPATIBILITY_MEMORY_ENABLED] = enabled
}
}
- suspend fun setPlayerSurfaceMode(mode: PlayerSurfaceMode) {
+ override suspend fun setPlayerSurfaceMode(mode: PlayerSurfaceMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_SURFACE_MODE] = mode.name
}
}
- suspend fun setPlayerLiveStreamFormatMode(mode: LiveStreamFormatMode) {
+ override suspend fun setPlayerLiveStreamFormatMode(mode: LiveStreamFormatMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_LIVE_STREAM_FORMAT_MODE] = mode.name
}
}
- suspend fun setPlayerVodHttpProtocolMode(mode: VodHttpProtocolMode) {
+ override suspend fun setPlayerVodHttpProtocolMode(mode: VodHttpProtocolMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_VOD_HTTP_PROTOCOL_MODE] = mode.name
preferences.remove(PreferencesKeys.LEGACY_PLAYER_MOVIE_HTTP_PROTOCOL_MODE)
}
}
- suspend fun setPlayerPlaybackSpeed(speed: Float) {
+ override suspend fun setPlayerPlaybackSpeed(speed: Float) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_PLAYBACK_SPEED] = speed.coerceIn(0.5f, 2f).toString()
}
}
- suspend fun setPlayerExternalPlaybackMode(mode: com.streamvault.domain.model.ExternalPlaybackMode) {
+ override suspend fun setPlayerExternalPlaybackMode(mode: com.streamvault.domain.model.ExternalPlaybackMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_EXTERNAL_PLAYBACK_MODE] = mode.storageValue
}
}
- suspend fun setPlayerAudioVideoOffsetMs(offsetMs: Int) {
+ override suspend fun setPlayerAudioVideoOffsetMs(offsetMs: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_AUDIO_VIDEO_OFFSET_MS] =
offsetMs.coerceIn(AUDIO_VIDEO_OFFSET_MIN_MS, AUDIO_VIDEO_OFFSET_MAX_MS)
}
}
- suspend fun setPlayerAudioVideoSyncEnabled(enabled: Boolean) {
+ override suspend fun setPlayerAudioVideoSyncEnabled(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_AUDIO_VIDEO_SYNC_ENABLED] = enabled
}
}
- suspend fun setPreferredAudioLanguage(languageTag: String?) {
+ override suspend fun setPreferredAudioLanguage(languageTag: String?) {
context.dataStore.edit { preferences ->
val normalized = languageTag
?.trim()
@@ -1123,31 +1125,31 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setPlayerSubtitleTextScale(scale: Float) {
+ override suspend fun setPlayerSubtitleTextScale(scale: Float) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_SUBTITLE_TEXT_SCALE] = scale.coerceIn(0.75f, 1.75f).toString()
}
}
- suspend fun setPlayerSubtitleTextColor(colorArgb: Int) {
+ override suspend fun setPlayerSubtitleTextColor(colorArgb: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_SUBTITLE_TEXT_COLOR] = colorArgb
}
}
- suspend fun setPlayerSubtitleBackgroundColor(colorArgb: Int) {
+ override suspend fun setPlayerSubtitleBackgroundColor(colorArgb: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_SUBTITLE_BACKGROUND_COLOR] = colorArgb
}
}
- suspend fun setPlayerLiveTranslationEnabled(enabled: Boolean) {
+ override suspend fun setPlayerLiveTranslationEnabled(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_LIVE_TRANSLATION_ENABLED] = enabled
}
}
- suspend fun setPlayerLiveTranslationEndpoint(endpoint: String) {
+ override suspend fun setPlayerLiveTranslationEndpoint(endpoint: String) {
context.dataStore.edit { preferences ->
val normalized = endpoint.trim()
if (normalized.isBlank()) {
@@ -1158,31 +1160,31 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setPlayerControlsTimeoutSeconds(seconds: Int) {
+ override suspend fun setPlayerControlsTimeoutSeconds(seconds: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_CONTROLS_TIMEOUT_SECONDS] = seconds.coerceIn(2, 60)
}
}
- suspend fun setPlayerLiveOverlayTimeoutSeconds(seconds: Int) {
+ override suspend fun setPlayerLiveOverlayTimeoutSeconds(seconds: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_LIVE_OVERLAY_TIMEOUT_SECONDS] = seconds.coerceIn(2, 60)
}
}
- suspend fun setPlayerNoticeTimeoutSeconds(seconds: Int) {
+ override suspend fun setPlayerNoticeTimeoutSeconds(seconds: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_NOTICE_TIMEOUT_SECONDS] = seconds.coerceIn(2, 60)
}
}
- suspend fun setPlayerDiagnosticsTimeoutSeconds(seconds: Int) {
+ override suspend fun setPlayerDiagnosticsTimeoutSeconds(seconds: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_DIAGNOSTICS_TIMEOUT_SECONDS] = seconds.coerceIn(2, 60)
}
}
- suspend fun setPlayerWifiMaxVideoHeight(maxHeight: Int?) {
+ override suspend fun setPlayerWifiMaxVideoHeight(maxHeight: Int?) {
context.dataStore.edit { preferences ->
val normalized = maxHeight?.takeIf { it > 0 }
if (normalized == null) {
@@ -1193,7 +1195,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setPlayerEthernetMaxVideoHeight(maxHeight: Int?) {
+ override suspend fun setPlayerEthernetMaxVideoHeight(maxHeight: Int?) {
context.dataStore.edit { preferences ->
val normalized = maxHeight?.takeIf { it > 0 }
if (normalized == null) {
@@ -1204,13 +1206,13 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setPlayerTimeshiftEnabled(enabled: Boolean) {
+ override suspend fun setPlayerTimeshiftEnabled(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_TIMESHIFT_ENABLED] = enabled
}
}
- suspend fun setPlayerTimeshiftDepthMinutes(minutes: Int) {
+ override suspend fun setPlayerTimeshiftDepthMinutes(minutes: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_TIMESHIFT_DEPTH_MINUTES] = when (minutes) {
15, 30, 60 -> minutes
@@ -1221,25 +1223,25 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setPlayerTimeshiftBackend(preference: TimeshiftBackendPreference) {
+ override suspend fun setPlayerTimeshiftBackend(preference: TimeshiftBackendPreference) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.PLAYER_TIMESHIFT_BACKEND] = preference.name
}
}
- suspend fun setDefaultStopPlaybackTimerMinutes(minutes: Int) {
+ override suspend fun setDefaultStopPlaybackTimerMinutes(minutes: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.DEFAULT_STOP_PLAYBACK_TIMER_MINUTES] = sanitizePlaybackTimerMinutes(minutes)
}
}
- suspend fun setDefaultIdleStandbyTimerMinutes(minutes: Int) {
+ override suspend fun setDefaultIdleStandbyTimerMinutes(minutes: Int) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.DEFAULT_IDLE_STANDBY_TIMER_MINUTES] = sanitizePlaybackTimerMinutes(minutes)
}
}
- suspend fun setLastSpeedTestResult(
+ override suspend fun setLastSpeedTestResult(
megabitsPerSecond: Double?,
measuredAtMs: Long?,
transport: String?,
@@ -1324,7 +1326,7 @@ class PreferencesRepository @Inject constructor(
clearLegacyRecentSearchQueries()
}
- suspend fun setParentalPin(pin: String) {
+ override suspend fun setParentalPin(pin: String) {
val salt = ByteArray(PIN_SALT_BYTES).also { secureRandom.nextBytes(it) }
val hash = hashPin(pin, salt)
val saltBase64 = java.util.Base64.getEncoder().encodeToString(salt)
@@ -1453,23 +1455,23 @@ class PreferencesRepository @Inject constructor(
}
}
- val appLanguage: Flow<String> = context.dataStore.data.map { preferences ->
+ override val appLanguage: Flow<String> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.APP_LANGUAGE] ?: "system"
}
- val remoteShortcutPreferences: Flow<RemoteShortcutPreferences> = context.dataStore.data.map { preferences ->
+ override val remoteShortcutPreferences: Flow<RemoteShortcutPreferences> = context.dataStore.data.map { preferences ->
decodeRemoteShortcutPreferences { profile, button ->
preferences[stringPreferencesKey(remoteShortcutKey(profile, button))]
}
}
- suspend fun setAppLanguage(language: String) {
+ override suspend fun setAppLanguage(language: String) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.APP_LANGUAGE] = language
}
}
- suspend fun setRemoteShortcutSelection(
+ override suspend fun setRemoteShortcutSelection(
profile: RemoteShortcutProfile,
button: RemoteColorButton,
selection: RemoteShortcutSelection
@@ -1485,109 +1487,109 @@ class PreferencesRepository @Inject constructor(
}
}
- val appLandingDestination: Flow<AppLandingDestination> = context.dataStore.data.map { preferences ->
+ override val appLandingDestination: Flow<AppLandingDestination> = context.dataStore.data.map { preferences ->
AppLandingDestination.fromStorage(preferences[PreferencesKeys.APP_LANDING_DESTINATION])
}
- val appTopLevelDestinations: Flow<List<AppTopLevelDestination>> = context.dataStore.data.map { preferences ->
+ override val appTopLevelDestinations: Flow<List<AppTopLevelDestination>> = context.dataStore.data.map { preferences ->
decodeAppTopLevelDestinations(preferences[PreferencesKeys.APP_TOP_LEVEL_DESTINATIONS])
}
- val appHomeDashboardShelves: Flow<List<AppHomeDashboardShelf>> = context.dataStore.data.map { preferences ->
+ override val appHomeDashboardShelves: Flow<List<AppHomeDashboardShelf>> = context.dataStore.data.map { preferences ->
decodeAppHomeDashboardShelves(preferences[PreferencesKeys.APP_HOME_DASHBOARD_SHELVES])
}
- suspend fun setAppLandingDestination(destination: AppLandingDestination) {
+ override suspend fun setAppLandingDestination(destination: AppLandingDestination) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.APP_LANDING_DESTINATION] = destination.storageValue
}
}
- suspend fun setAppTopLevelDestinations(destinations: List<AppTopLevelDestination>) {
+ override suspend fun setAppTopLevelDestinations(destinations: List<AppTopLevelDestination>) {
val normalized = AppTopLevelDestination.normalizeForStorage(destinations)
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.APP_TOP_LEVEL_DESTINATIONS] = encodeAppTopLevelDestinations(normalized)
}
}
- suspend fun setAppHomeDashboardShelves(shelves: List<AppHomeDashboardShelf>) {
+ override suspend fun setAppHomeDashboardShelves(shelves: List<AppHomeDashboardShelf>) {
val normalized = AppHomeDashboardShelf.normalizeForStorage(shelves)
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.APP_HOME_DASHBOARD_SHELVES] = encodeAppHomeDashboardShelves(normalized)
}
}
- val appTimeFormat: Flow<AppTimeFormat> = context.dataStore.data.map { preferences ->
+ override val appTimeFormat: Flow<AppTimeFormat> = context.dataStore.data.map { preferences ->
AppTimeFormat.fromStorage(preferences[PreferencesKeys.APP_TIME_FORMAT])
}
- suspend fun setAppTimeFormat(format: AppTimeFormat) {
+ override suspend fun setAppTimeFormat(format: AppTimeFormat) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.APP_TIME_FORMAT] = format.storageValue
}
}
- val liveTvChannelMode: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val liveTvChannelMode: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LIVE_TV_CHANNEL_MODE]
}
- suspend fun setLiveTvChannelMode(mode: String) {
+ override suspend fun setLiveTvChannelMode(mode: String) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.LIVE_TV_CHANNEL_MODE] = mode
}
}
- val showLiveSourceSwitcher: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val showLiveSourceSwitcher: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.SHOW_LIVE_SOURCE_SWITCHER] ?: false
}
- suspend fun setShowLiveSourceSwitcher(enabled: Boolean) {
+ override suspend fun setShowLiveSourceSwitcher(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.SHOW_LIVE_SOURCE_SWITCHER] = enabled
}
}
- val showFavoritesCategory: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val showFavoritesCategory: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.SHOW_FAVORITES_CATEGORY] ?: true
}
- suspend fun setShowFavoritesCategory(enabled: Boolean) {
+ override suspend fun setShowFavoritesCategory(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.SHOW_FAVORITES_CATEGORY] = enabled
}
}
- val showAllChannelsCategory: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val showAllChannelsCategory: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.SHOW_ALL_CHANNELS_CATEGORY] ?: true
}
- suspend fun setShowAllChannelsCategory(enabled: Boolean) {
+ override suspend fun setShowAllChannelsCategory(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.SHOW_ALL_CHANNELS_CATEGORY] = enabled
}
}
- val showRecentChannelsCategory: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val showRecentChannelsCategory: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.SHOW_RECENT_CHANNELS_CATEGORY] ?: true
}
- suspend fun setShowRecentChannelsCategory(enabled: Boolean) {
+ override suspend fun setShowRecentChannelsCategory(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.SHOW_RECENT_CHANNELS_CATEGORY] = enabled
}
}
- val liveTvQuickFilterVisibility: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val liveTvQuickFilterVisibility: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LIVE_TV_QUICK_FILTER_VISIBILITY]
}
- suspend fun setLiveTvQuickFilterVisibility(mode: String) {
+ override suspend fun setLiveTvQuickFilterVisibility(mode: String) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.LIVE_TV_QUICK_FILTER_VISIBILITY] = mode
}
}
- val liveTvCategoryFilters: Flow<List<String>> = context.dataStore.data.map { preferences ->
+ override val liveTvCategoryFilters: Flow<List<String>> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.LIVE_TV_CATEGORY_FILTERS]
?.split('\n')
.orEmpty()
@@ -1605,7 +1607,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun addLiveTvCategoryFilter(filter: String): Boolean {
+ override suspend fun addLiveTvCategoryFilter(filter: String): Boolean {
val normalized = filter.trim()
if (normalized.isBlank()) return false
val current = liveTvCategoryFilters.first()
@@ -1616,7 +1618,7 @@ class PreferencesRepository @Inject constructor(
return true
}
- suspend fun removeLiveTvCategoryFilter(filter: String): Boolean {
+ override suspend fun removeLiveTvCategoryFilter(filter: String): Boolean {
val current = liveTvCategoryFilters.first()
val updated = current.filterNot { it.equals(filter, ignoreCase = true) }
if (updated.size == current.size) {
@@ -1626,51 +1628,51 @@ class PreferencesRepository @Inject constructor(
return true
}
- val hideDecorativeLiveRows: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val hideDecorativeLiveRows: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.HIDE_DECORATIVE_LIVE_ROWS] ?: true
}
- suspend fun setHideDecorativeLiveRows(hide: Boolean) {
+ override suspend fun setHideDecorativeLiveRows(hide: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.HIDE_DECORATIVE_LIVE_ROWS] = hide
}
}
- val liveChannelNumberingMode: Flow<ChannelNumberingMode> = context.dataStore.data.map { preferences ->
+ override val liveChannelNumberingMode: Flow<ChannelNumberingMode> = context.dataStore.data.map { preferences ->
ChannelNumberingMode.fromStorage(preferences[PreferencesKeys.LIVE_CHANNEL_NUMBERING_MODE])
}
- suspend fun setLiveChannelNumberingMode(mode: ChannelNumberingMode) {
+ override suspend fun setLiveChannelNumberingMode(mode: ChannelNumberingMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.LIVE_CHANNEL_NUMBERING_MODE] = mode.storageValue
}
}
- val liveChannelGroupingMode: Flow<LiveChannelGroupingMode> = context.dataStore.data.map { preferences ->
+ override val liveChannelGroupingMode: Flow<LiveChannelGroupingMode> = context.dataStore.data.map { preferences ->
LiveChannelGroupingMode.fromStorage(preferences[PreferencesKeys.LIVE_CHANNEL_GROUPING_MODE])
}
- suspend fun setLiveChannelGroupingMode(mode: LiveChannelGroupingMode) {
+ override suspend fun setLiveChannelGroupingMode(mode: LiveChannelGroupingMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.LIVE_CHANNEL_GROUPING_MODE] = mode.storageValue
}
}
- val groupedChannelLabelMode: Flow<GroupedChannelLabelMode> = context.dataStore.data.map { preferences ->
+ override val groupedChannelLabelMode: Flow<GroupedChannelLabelMode> = context.dataStore.data.map { preferences ->
GroupedChannelLabelMode.fromStorage(preferences[PreferencesKeys.GROUPED_CHANNEL_LABEL_MODE])
}
- suspend fun setGroupedChannelLabelMode(mode: GroupedChannelLabelMode) {
+ override suspend fun setGroupedChannelLabelMode(mode: GroupedChannelLabelMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.GROUPED_CHANNEL_LABEL_MODE] = mode.storageValue
}
}
- val liveVariantPreferenceMode: Flow<LiveVariantPreferenceMode> = context.dataStore.data.map { preferences ->
+ override val liveVariantPreferenceMode: Flow<LiveVariantPreferenceMode> = context.dataStore.data.map { preferences ->
LiveVariantPreferenceMode.fromStorage(preferences[PreferencesKeys.LIVE_VARIANT_PREFERENCE_MODE])
}
- suspend fun setLiveVariantPreferenceMode(mode: LiveVariantPreferenceMode) {
+ override suspend fun setLiveVariantPreferenceMode(mode: LiveVariantPreferenceMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.LIVE_VARIANT_PREFERENCE_MODE] = mode.storageValue
}
@@ -1725,21 +1727,21 @@ class PreferencesRepository @Inject constructor(
}
}
- val vodDuplicateHandlingMode: Flow<VodDuplicateHandlingMode> = context.dataStore.data.map { preferences ->
+ override val vodDuplicateHandlingMode: Flow<VodDuplicateHandlingMode> = context.dataStore.data.map { preferences ->
VodDuplicateHandlingMode.fromStorage(preferences[PreferencesKeys.VOD_DUPLICATE_HANDLING_MODE])
}
- suspend fun setVodDuplicateHandlingMode(mode: VodDuplicateHandlingMode) {
+ override suspend fun setVodDuplicateHandlingMode(mode: VodDuplicateHandlingMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.VOD_DUPLICATE_HANDLING_MODE] = mode.storageValue
}
}
- val vodVariantPreferenceMode: Flow<VodVariantPreferenceMode> = context.dataStore.data.map { preferences ->
+ override val vodVariantPreferenceMode: Flow<VodVariantPreferenceMode> = context.dataStore.data.map { preferences ->
VodVariantPreferenceMode.fromStorage(preferences[PreferencesKeys.VOD_VARIANT_PREFERENCE_MODE])
}
- suspend fun setVodVariantPreferenceMode(mode: VodVariantPreferenceMode) {
+ override suspend fun setVodVariantPreferenceMode(mode: VodVariantPreferenceMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.VOD_VARIANT_PREFERENCE_MODE] = mode.storageValue
}
@@ -1794,34 +1796,34 @@ class PreferencesRepository @Inject constructor(
}
}
- val vodViewMode: Flow<String?> = context.dataStore.data.map { preferences ->
+ override val vodViewMode: Flow<String?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.VOD_VIEW_MODE]
}
- suspend fun setVodViewMode(mode: String) {
+ override suspend fun setVodViewMode(mode: String) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.VOD_VIEW_MODE] = mode
}
}
- val vodInfiniteScroll: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val vodInfiniteScroll: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.VOD_INFINITE_SCROLL] ?: true
}
- suspend fun setVodInfiniteScroll(enabled: Boolean) {
+ override suspend fun setVodInfiniteScroll(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.VOD_INFINITE_SCROLL] = enabled
}
}
- val vodCategoryLoadMode: Flow<com.streamvault.domain.model.VodCategoryLoadMode> =
+ override val vodCategoryLoadMode: Flow<com.streamvault.domain.model.VodCategoryLoadMode> =
context.dataStore.data.map { preferences ->
com.streamvault.domain.model.VodCategoryLoadMode.fromStorage(
preferences[PreferencesKeys.VOD_CATEGORY_LOAD_MODE]
)
}
- suspend fun setVodCategoryLoadMode(mode: com.streamvault.domain.model.VodCategoryLoadMode) {
+ override suspend fun setVodCategoryLoadMode(mode: com.streamvault.domain.model.VodCategoryLoadMode) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.VOD_CATEGORY_LOAD_MODE] = mode.storageValue
}
@@ -1847,11 +1849,11 @@ class PreferencesRepository @Inject constructor(
}
}
- val guideDefaultCategoryId: Flow<Long?> = context.dataStore.data.map { preferences ->
+ override val guideDefaultCategoryId: Flow<Long?> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.GUIDE_DEFAULT_CATEGORY_ID]
}
- suspend fun setGuideDefaultCategoryId(categoryId: Long) {
+ override suspend fun setGuideDefaultCategoryId(categoryId: Long) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.GUIDE_DEFAULT_CATEGORY_ID] = categoryId
}
@@ -1915,7 +1917,7 @@ class PreferencesRepository @Inject constructor(
.filter { it.value != 0 }
.joinToString(",") { "${it.key}:${it.value}" }
- val epgTimeShiftsByProvider: Flow<Map<Long, Int>> = context.dataStore.data.map { prefs ->
+ override val epgTimeShiftsByProvider: Flow<Map<Long, Int>> = context.dataStore.data.map { prefs ->
decodeEpgTimeShifts(prefs[PreferencesKeys.EPG_TIME_SHIFT_BY_PROVIDER])
}
@@ -1925,7 +1927,7 @@ class PreferencesRepository @Inject constructor(
suspend fun getEpgTimeShiftMinutes(providerId: Long): Int =
epgTimeShiftsByProvider.first()[providerId] ?: 0
- suspend fun setEpgTimeShiftMinutes(providerId: Long, minutes: Int) {
+ override suspend fun setEpgTimeShiftMinutes(providerId: Long, minutes: Int) {
context.dataStore.edit { prefs ->
val current = decodeEpgTimeShifts(prefs[PreferencesKeys.EPG_TIME_SHIFT_BY_PROVIDER]).toMutableMap()
if (minutes == 0) current.remove(providerId) else current[providerId] = minutes
@@ -1956,7 +1958,7 @@ class PreferencesRepository @Inject constructor(
}
}
- fun getHiddenCategoryIds(providerId: Long, type: ContentType): Flow<Set<Long>> {
+ override fun getHiddenCategoryIds(providerId: Long, type: ContentType): Flow<Set<Long>> {
val key = stringPreferencesKey(hiddenCategoriesKey(providerId, type))
return context.dataStore.data.map { preferences ->
preferences[key]
@@ -1967,7 +1969,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setCategoryHidden(
+ override suspend fun setCategoryHidden(
providerId: Long,
type: ContentType,
categoryId: Long,
@@ -1993,7 +1995,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setHiddenCategoryIds(
+ override suspend fun setHiddenCategoryIds(
providerId: Long,
type: ContentType,
categoryIds: Set<Long>
@@ -2156,7 +2158,7 @@ class PreferencesRepository @Inject constructor(
}
}
- fun getCategorySortMode(providerId: Long, type: ContentType): Flow<CategorySortMode> {
+ override fun getCategorySortMode(providerId: Long, type: ContentType): Flow<CategorySortMode> {
val key = stringPreferencesKey(categorySortModeKey(providerId, type))
return context.dataStore.data.map { preferences ->
preferences[key]
@@ -2165,7 +2167,7 @@ class PreferencesRepository @Inject constructor(
}
}
- suspend fun setCategorySortMode(providerId: Long, type: ContentType, mode: CategorySortMode) {
+ override suspend fun setCategorySortMode(providerId: Long, type: ContentType, mode: CategorySortMode) {
val key = stringPreferencesKey(categorySortModeKey(providerId, type))
context.dataStore.edit { preferences ->
preferences[key] = mode.name
@@ -2211,21 +2213,21 @@ class PreferencesRepository @Inject constructor(
}
}
- val multiViewCenterTwoSlotLayout: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val multiViewCenterTwoSlotLayout: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.MULTIVIEW_CENTER_TWO_SLOT_LAYOUT] ?: false
}
- suspend fun setMultiViewCenterTwoSlotLayout(enabled: Boolean) {
+ override suspend fun setMultiViewCenterTwoSlotLayout(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.MULTIVIEW_CENTER_TWO_SLOT_LAYOUT] = enabled
}
}
- val multiViewRespectProviderConnectionLimit: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ override val multiViewRespectProviderConnectionLimit: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.MULTIVIEW_RESPECT_PROVIDER_CONNECTION_LIMIT] ?: true
}
- suspend fun setMultiViewRespectProviderConnectionLimit(enabled: Boolean) {
+ override suspend fun setMultiViewRespectProviderConnectionLimit(enabled: Boolean) {
context.dataStore.edit { preferences ->
preferences[PreferencesKeys.MULTIVIEW_RESPECT_PROVIDER_CONNECTION_LIMIT] = enabled
}
@@ -2268,7 +2270,7 @@ class PreferencesRepository @Inject constructor(
channelPreferenceDao.setAudioVideoOffset(channelId = channelId, offsetMs = null)
}
- suspend fun clearAllRecentData() {
+ override suspend fun clearAllRecentData() {
channelPreferenceDao.deleteAll()
searchHistoryDao.deleteAll()
context.dataStore.edit { preferences ->
@@ -2542,23 +2544,3 @@ data class ParentalPinBackupData(
val hash: String,
val saltBase64: String
)
-
-data class DatabaseMaintenanceSnapshot(
- val ranAt: Long,
- val deletedPrograms: Int,
- val deletedExternalProgrammes: Int,
- val deletedOrphanEpisodes: Int,
- val deletedStaleFavorites: Int,
- val vacuumRan: Boolean,
- val mainDbBytes: Long,
- val walBytes: Long,
- val reclaimableBytes: Long,
- val channelRows: Long,
- val movieRows: Long,
- val seriesRows: Long,
- val episodeRows: Long,
- val programRows: Long,
- val epgProgrammeRows: Long,
- val playbackHistoryRows: Long,
- val favoriteRows: Long
-)
diff --git a/data/src/main/java/com/streamvault/data/sync/SyncWorker.kt b/data/src/main/java/com/streamvault/data/sync/SyncWorker.kt
index e03e36fa..303a3a53 100644
--- a/data/src/main/java/com/streamvault/data/sync/SyncWorker.kt
+++ b/data/src/main/java/com/streamvault/data/sync/SyncWorker.kt
@@ -6,7 +6,7 @@ import android.database.sqlite.SQLiteFullException
import android.util.Log
import androidx.work.CoroutineWorker
import androidx.work.WorkerParameters
-import com.streamvault.data.preferences.DatabaseMaintenanceSnapshot
+import com.streamvault.domain.settings.DatabaseMaintenanceSnapshot
import com.streamvault.data.preferences.PreferencesRepository
import dagger.hilt.EntryPoint
import dagger.hilt.InstallIn
diff --git a/data/src/test/java/com/streamvault/data/sync/SyncWorkerPolicyTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncWorkerPolicyTest.kt
index cc059cbe..cbf03e1d 100644
--- a/data/src/test/java/com/streamvault/data/sync/SyncWorkerPolicyTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/SyncWorkerPolicyTest.kt
@@ -3,7 +3,7 @@ package com.streamvault.data.sync
import android.database.sqlite.SQLiteException
import android.database.sqlite.SQLiteFullException
import com.google.common.truth.Truth.assertThat
-import com.streamvault.data.preferences.DatabaseMaintenanceSnapshot
+import com.streamvault.domain.settings.DatabaseMaintenanceSnapshot
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.test.runTest
import org.mockito.kotlin.mock
diff --git a/domain/src/main/java/com/streamvault/domain/settings/DatabaseMaintenanceSnapshot.kt b/domain/src/main/java/com/streamvault/domain/settings/DatabaseMaintenanceSnapshot.kt
new file mode 100644
index 00000000..6c832c7c
--- /dev/null
+++ b/domain/src/main/java/com/streamvault/domain/settings/DatabaseMaintenanceSnapshot.kt
@@ -0,0 +1,21 @@
+package com.streamvault.domain.settings
+
+data class DatabaseMaintenanceSnapshot(
+ val ranAt: Long,
+ val deletedPrograms: Int,
+ val deletedExternalProgrammes: Int,
+ val deletedOrphanEpisodes: Int,
+ val deletedStaleFavorites: Int,
+ val vacuumRan: Boolean,
+ val mainDbBytes: Long,
+ val walBytes: Long,
+ val reclaimableBytes: Long,
+ val channelRows: Long,
+ val movieRows: Long,
+ val seriesRows: Long,
+ val episodeRows: Long,
+ val programRows: Long,
+ val epgProgrammeRows: Long,
+ val playbackHistoryRows: Long,
+ val favoriteRows: Long
+)
diff --git a/domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.kt b/domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.kt
new file mode 100644
index 00000000..9744c16f
--- /dev/null
+++ b/domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.kt
@@ -0,0 +1,408 @@
+package com.streamvault.domain.settings
+
+import com.streamvault.domain.model.GroupedChannelLabelMode
+import com.streamvault.domain.model.AudioOutputPreference
+import com.streamvault.domain.model.ChannelNumberingMode
+import com.streamvault.domain.model.CategorySortMode
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.DecoderMode
+import com.streamvault.domain.model.AppHomeDashboardShelf
+import com.streamvault.domain.model.AppLandingDestination
+import com.streamvault.domain.model.AppTimeFormat
+import com.streamvault.domain.model.LiveChannelGroupingMode
+import com.streamvault.domain.model.LiveStreamFormatMode
+import com.streamvault.domain.model.LiveVariantPreferenceMode
+import com.streamvault.domain.model.AppTopLevelDestination
+import com.streamvault.domain.model.PlaybackBufferMode
+import com.streamvault.domain.model.VodDuplicateHandlingMode
+import com.streamvault.domain.model.VodHttpProtocolMode
+import com.streamvault.domain.model.VodVariantPreferenceMode
+import com.streamvault.domain.model.PlayerSurfaceMode
+import com.streamvault.domain.model.RemoteColorButton
+import com.streamvault.domain.model.RemoteShortcutPreferences
+import com.streamvault.domain.model.RemoteShortcutProfile
+import com.streamvault.domain.model.RemoteShortcutSelection
+import com.streamvault.domain.model.TimeshiftBackendPreference
+import kotlinx.coroutines.flow.Flow
+
+/** Preference streams and commands consumed by settings; persistence remains in the data layer. */
+interface SettingsPreferences {
+ val isIncognitoMode: Flow<Boolean>
+
+ val useXtreamTextClassification: Flow<Boolean>
+
+ val xtreamBase64TextCompatibility: Flow<Boolean>
+
+ val playerMediaSessionEnabled: Flow<Boolean>
+
+ val playerFastRetryOnTransientFailures: Flow<Boolean>
+
+ val playerAudioDecoderMode: Flow<DecoderMode>
+
+ val playerVideoDecoderMode: Flow<DecoderMode>
+
+ val playerPlaybackBufferMode: Flow<PlaybackBufferMode>
+
+ val playerSurfaceMode: Flow<PlayerSurfaceMode>
+
+ val playerLiveStreamFormatMode: Flow<LiveStreamFormatMode>
+
+ val playerVodHttpProtocolMode: Flow<VodHttpProtocolMode>
+
+ val playerAudioOutputPreference: Flow<AudioOutputPreference>
+
+ val playerCompatibilityMemoryEnabled: Flow<Boolean>
+
+ val playerPlaybackSpeed: Flow<Float>
+
+ val playerExternalPlaybackMode: Flow<com.streamvault.domain.model.ExternalPlaybackMode>
+
+ val playerAudioVideoOffsetMs: Flow<Int>
+
+ val playerAudioVideoSyncEnabled: Flow<Boolean>
+
+ val preferredAudioLanguage: Flow<String?>
+
+ val playerSubtitleTextScale: Flow<Float>
+
+ val playerSubtitleTextColor: Flow<Int>
+
+ val playerSubtitleBackgroundColor: Flow<Int>
+
+ val playerLiveTranslationEnabled: Flow<Boolean>
+
+ val playerLiveTranslationEndpoint: Flow<String>
+
+ val playerControlsTimeoutSeconds: Flow<Int>
+
+ val playerLiveOverlayTimeoutSeconds: Flow<Int>
+
+ val playerNoticeTimeoutSeconds: Flow<Int>
+
+ val playerDiagnosticsTimeoutSeconds: Flow<Int>
+
+ val playerWifiMaxVideoHeight: Flow<Int?>
+
+ val playerEthernetMaxVideoHeight: Flow<Int?>
+
+ val playerTimeshiftEnabled: Flow<Boolean>
+
+ val playerTimeshiftDepthMinutes: Flow<Int>
+
+ val playerTimeshiftBackend: Flow<TimeshiftBackendPreference>
+
+ val defaultStopPlaybackTimerMinutes: Flow<Int>
+
+ val defaultIdleStandbyTimerMinutes: Flow<Int>
+
+ val lastSpeedTestMegabits: Flow<Double?>
+
+ val lastSpeedTestTimestamp: Flow<Long?>
+
+ val lastSpeedTestTransport: Flow<String?>
+
+ val lastSpeedTestRecommendedHeight: Flow<Int?>
+
+ val lastSpeedTestEstimated: Flow<Boolean>
+
+ val parentalControlLevel: Flow<Int>
+
+ val hasParentalPin: Flow<Boolean>
+
+ suspend fun setLastActiveProviderId(id: Long)
+
+ suspend fun setParentalControlLevel(level: Int)
+
+ suspend fun setIncognitoMode(enabled: Boolean)
+
+ suspend fun setUseXtreamTextClassification(enabled: Boolean)
+
+ suspend fun setXtreamBase64TextCompatibility(enabled: Boolean)
+
+ suspend fun bumpXtreamTextImportGeneration(): Long
+
+ suspend fun getXtreamTextImportGeneration(): Long
+
+ suspend fun getXtreamTextImportAppliedGeneration(providerId: Long): Long
+
+ suspend fun markXtreamTextImportApplied(providerId: Long, generation: Long)
+
+ val preventStandbyDuringPlayback: Flow<Boolean>
+
+ val autoPlayNextEpisode: Flow<Boolean>
+
+ val autoCheckAppUpdates: Flow<Boolean>
+
+ val autoDownloadAppUpdates: Flow<Boolean>
+
+ val lastAppUpdateCheckTimestamp: Flow<Long?>
+
+ val lastAppUpdateFailureTimestamp: Flow<Long?>
+
+ val cachedAppUpdateVersionName: Flow<String?>
+
+ val cachedAppUpdateVersionCode: Flow<Int?>
+
+ val cachedAppUpdateReleaseUrl: Flow<String?>
+
+ val cachedAppUpdateDownloadUrl: Flow<String?>
+
+ val cachedAppUpdateDownloadSha256: Flow<String?>
+
+ val cachedAppUpdateReleaseNotes: Flow<String>
+
+ val cachedAppUpdatePublishedAt: Flow<String?>
+
+ val lastMaintenanceSnapshot: Flow<DatabaseMaintenanceSnapshot?>
+
+ val zapAutoRevert: Flow<Boolean>
+
+ val recordingWifiOnly: Flow<Boolean>
+
+ val recordingPaddingBeforeMinutes: Flow<Int>
+
+ val recordingPaddingAfterMinutes: Flow<Int>
+
+ suspend fun setZapAutoRevert(enabled: Boolean)
+
+ suspend fun setRecordingWifiOnly(enabled: Boolean)
+
+ suspend fun setRecordingPaddingBeforeMinutes(minutes: Int)
+
+ suspend fun setRecordingPaddingAfterMinutes(minutes: Int)
+
+ suspend fun setPreventStandbyDuringPlayback(prevent: Boolean)
+
+ suspend fun setAutoPlayNextEpisode(enabled: Boolean)
+
+ suspend fun setAutoCheckAppUpdates(enabled: Boolean)
+
+ suspend fun setAutoDownloadAppUpdates(enabled: Boolean)
+
+ suspend fun setLastAppUpdateCheckTimestamp(timestampMs: Long?)
+
+ suspend fun setLastAppUpdateFailureTimestamp(timestampMs: Long?)
+
+ suspend fun setLastAppUpdateAttemptTimestamp(timestampMs: Long?)
+
+ suspend fun setLastAppUpdateOutcome(outcome: String?)
+
+ suspend fun setCachedAppUpdateRelease(
+ versionName: String?,
+ versionCode: Int?,
+ releaseUrl: String?,
+ downloadUrl: String?,
+ downloadSha256: String?,
+ releaseNotes: String?,
+ publishedAt: String?
+ )
+
+ suspend fun setPlayerMediaSessionEnabled(enabled: Boolean)
+
+ suspend fun setPlayerFastRetryOnTransientFailures(enabled: Boolean)
+
+ suspend fun setPlayerAudioDecoderMode(mode: DecoderMode)
+
+ suspend fun setPlayerVideoDecoderMode(mode: DecoderMode)
+
+ suspend fun setPlayerPlaybackBufferMode(mode: PlaybackBufferMode)
+
+ suspend fun setPlayerAudioOutputPreference(preference: AudioOutputPreference)
+
+ suspend fun setPlayerCompatibilityMemoryEnabled(enabled: Boolean)
+
+ suspend fun setPlayerSurfaceMode(mode: PlayerSurfaceMode)
+
+ suspend fun setPlayerLiveStreamFormatMode(mode: LiveStreamFormatMode)
+
+ suspend fun setPlayerVodHttpProtocolMode(mode: VodHttpProtocolMode)
+
+ suspend fun setPlayerPlaybackSpeed(speed: Float)
+
+ suspend fun setPlayerExternalPlaybackMode(mode: com.streamvault.domain.model.ExternalPlaybackMode)
+
+ suspend fun setPlayerAudioVideoOffsetMs(offsetMs: Int)
+
+ suspend fun setPlayerAudioVideoSyncEnabled(enabled: Boolean)
+
+ suspend fun setPreferredAudioLanguage(languageTag: String?)
+
+ suspend fun setPlayerSubtitleTextScale(scale: Float)
+
+ suspend fun setPlayerSubtitleTextColor(colorArgb: Int)
+
+ suspend fun setPlayerSubtitleBackgroundColor(colorArgb: Int)
+
+ suspend fun setPlayerLiveTranslationEnabled(enabled: Boolean)
+
+ suspend fun setPlayerLiveTranslationEndpoint(endpoint: String)
+
+ suspend fun setPlayerControlsTimeoutSeconds(seconds: Int)
+
+ suspend fun setPlayerLiveOverlayTimeoutSeconds(seconds: Int)
+
+ suspend fun setPlayerNoticeTimeoutSeconds(seconds: Int)
+
+ suspend fun setPlayerDiagnosticsTimeoutSeconds(seconds: Int)
+
+ suspend fun setPlayerWifiMaxVideoHeight(maxHeight: Int?)
+
+ suspend fun setPlayerEthernetMaxVideoHeight(maxHeight: Int?)
+
+ suspend fun setPlayerTimeshiftEnabled(enabled: Boolean)
+
+ suspend fun setPlayerTimeshiftDepthMinutes(minutes: Int)
+
+ suspend fun setPlayerTimeshiftBackend(preference: TimeshiftBackendPreference)
+
+ suspend fun setDefaultStopPlaybackTimerMinutes(minutes: Int)
+
+ suspend fun setDefaultIdleStandbyTimerMinutes(minutes: Int)
+
+ suspend fun setLastSpeedTestResult(
+ megabitsPerSecond: Double?,
+ measuredAtMs: Long?,
+ transport: String?,
+ recommendedMaxHeight: Int?,
+ estimated: Boolean
+ )
+
+ suspend fun setParentalPin(pin: String)
+
+ suspend fun verifyParentalPin(pin: String): Boolean
+
+ val appLanguage: Flow<String>
+
+ val remoteShortcutPreferences: Flow<RemoteShortcutPreferences>
+
+ suspend fun setAppLanguage(language: String)
+
+ suspend fun setRemoteShortcutSelection(
+ profile: RemoteShortcutProfile,
+ button: RemoteColorButton,
+ selection: RemoteShortcutSelection
+ )
+
+ val appLandingDestination: Flow<AppLandingDestination>
+
+ val appTopLevelDestinations: Flow<List<AppTopLevelDestination>>
+
+ val appHomeDashboardShelves: Flow<List<AppHomeDashboardShelf>>
+
+ suspend fun setAppLandingDestination(destination: AppLandingDestination)
+
+ suspend fun setAppTopLevelDestinations(destinations: List<AppTopLevelDestination>)
+
+ suspend fun setAppHomeDashboardShelves(shelves: List<AppHomeDashboardShelf>)
+
+ val appTimeFormat: Flow<AppTimeFormat>
+
+ suspend fun setAppTimeFormat(format: AppTimeFormat)
+
+ val liveTvChannelMode: Flow<String?>
+
+ suspend fun setLiveTvChannelMode(mode: String)
+
+ val showLiveSourceSwitcher: Flow<Boolean>
+
+ suspend fun setShowLiveSourceSwitcher(enabled: Boolean)
+
+ val showFavoritesCategory: Flow<Boolean>
+
+ suspend fun setShowFavoritesCategory(enabled: Boolean)
+
+ val showAllChannelsCategory: Flow<Boolean>
+
+ suspend fun setShowAllChannelsCategory(enabled: Boolean)
+
+ val showRecentChannelsCategory: Flow<Boolean>
+
+ suspend fun setShowRecentChannelsCategory(enabled: Boolean)
+
+ val liveTvQuickFilterVisibility: Flow<String?>
+
+ suspend fun setLiveTvQuickFilterVisibility(mode: String)
+
+ val liveTvCategoryFilters: Flow<List<String>>
+
+ suspend fun addLiveTvCategoryFilter(filter: String): Boolean
+
+ suspend fun removeLiveTvCategoryFilter(filter: String): Boolean
+
+ val hideDecorativeLiveRows: Flow<Boolean>
+
+ suspend fun setHideDecorativeLiveRows(hide: Boolean)
+
+ val liveChannelNumberingMode: Flow<ChannelNumberingMode>
+
+ suspend fun setLiveChannelNumberingMode(mode: ChannelNumberingMode)
+
+ val liveChannelGroupingMode: Flow<LiveChannelGroupingMode>
+
+ suspend fun setLiveChannelGroupingMode(mode: LiveChannelGroupingMode)
+
+ val groupedChannelLabelMode: Flow<GroupedChannelLabelMode>
+
+ suspend fun setGroupedChannelLabelMode(mode: GroupedChannelLabelMode)
+
+ val liveVariantPreferenceMode: Flow<LiveVariantPreferenceMode>
+
+ suspend fun setLiveVariantPreferenceMode(mode: LiveVariantPreferenceMode)
+
+ val vodDuplicateHandlingMode: Flow<VodDuplicateHandlingMode>
+
+ suspend fun setVodDuplicateHandlingMode(mode: VodDuplicateHandlingMode)
+
+ val vodVariantPreferenceMode: Flow<VodVariantPreferenceMode>
+
+ suspend fun setVodVariantPreferenceMode(mode: VodVariantPreferenceMode)
+
+ val vodViewMode: Flow<String?>
+
+ suspend fun setVodViewMode(mode: String)
+
+ val vodInfiniteScroll: Flow<Boolean>
+
+ suspend fun setVodInfiniteScroll(enabled: Boolean)
+
+ val vodCategoryLoadMode: Flow<com.streamvault.domain.model.VodCategoryLoadMode>
+
+ suspend fun setVodCategoryLoadMode(mode: com.streamvault.domain.model.VodCategoryLoadMode)
+
+ val guideDefaultCategoryId: Flow<Long?>
+
+ suspend fun setGuideDefaultCategoryId(categoryId: Long)
+
+ val epgTimeShiftsByProvider: Flow<Map<Long, Int>>
+
+ suspend fun setEpgTimeShiftMinutes(providerId: Long, minutes: Int)
+
+ fun getHiddenCategoryIds(providerId: Long, type: ContentType): Flow<Set<Long>>
+
+ suspend fun setCategoryHidden(
+ providerId: Long,
+ type: ContentType,
+ categoryId: Long,
+ hidden: Boolean
+ )
+
+ suspend fun setHiddenCategoryIds(
+ providerId: Long,
+ type: ContentType,
+ categoryIds: Set<Long>
+ )
+
+ fun getCategorySortMode(providerId: Long, type: ContentType): Flow<CategorySortMode>
+
+ suspend fun setCategorySortMode(providerId: Long, type: ContentType, mode: CategorySortMode)
+
+ val multiViewCenterTwoSlotLayout: Flow<Boolean>
+
+ suspend fun setMultiViewCenterTwoSlotLayout(enabled: Boolean)
+
+ val multiViewRespectProviderConnectionLimit: Flow<Boolean>
+
+ suspend fun setMultiViewRespectProviderConnectionLimit(enabled: Boolean)
+
+ suspend fun clearAllRecentData()
+}
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModel.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModel.kt
index 626807e3..91feeb2d 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModel.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModel.kt
@@ -3,7 +3,7 @@ package com.streamvault.feature.settings.parental
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.Result
@@ -45,7 +45,7 @@ data class ParentalControlGroupUiState(
@HiltViewModel
class ParentalControlGroupViewModel @Inject constructor(
private val categoryRepository: CategoryRepository,
- private val preferencesRepository: PreferencesRepository,
+ private val preferencesRepository: SettingsPreferences,
savedStateHandle: SavedStateHandle
) : ViewModel() {
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActions.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActions.kt
index 491aaa8f..5a809e4d 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActions.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActions.kt
@@ -7,13 +7,13 @@ import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import com.streamvault.feature.settings.R
import com.streamvault.feature.settings.api.SettingsAppUpdatePort
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.domain.model.Result
import com.streamvault.feature.settings.api.SettingsUpdateActionState
internal class SettingsAppUpdateActions(
private val appContext: Context,
- private val preferencesRepository: PreferencesRepository,
+ private val preferencesRepository: SettingsPreferences,
private val appUpdatePort: SettingsAppUpdatePort,
private val uiState: MutableStateFlow<SettingsUiState>
) {
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDerivedStateObservers.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDerivedStateObservers.kt
index 97b05ade..e59ed4d1 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDerivedStateObservers.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDerivedStateObservers.kt
@@ -91,7 +91,7 @@ internal fun observeProviderDiagnostics(
internal fun observeCategoryManagement(
activeProviderIdFlow: Flow<Long?>,
- preferencesRepository: com.streamvault.data.preferences.PreferencesRepository,
+ preferencesRepository: com.streamvault.domain.settings.SettingsPreferences,
categoryRepository: CategoryRepository
): Flow<CategoryManagementSnapshot> {
return activeProviderIdFlow.flatMapLatest { providerId ->
@@ -116,7 +116,7 @@ internal fun observeCategoryManagement(
private fun observeCategorySortModes(
providerId: Long,
- preferencesRepository: com.streamvault.data.preferences.PreferencesRepository
+ preferencesRepository: com.streamvault.domain.settings.SettingsPreferences
): Flow<Map<ContentType, CategorySortMode>> {
return combine(
preferencesRepository.getCategorySortMode(providerId, ContentType.LIVE),
@@ -133,7 +133,7 @@ private fun observeCategorySortModes(
private fun observeHiddenCategoryIdsByType(
providerId: Long,
- preferencesRepository: com.streamvault.data.preferences.PreferencesRepository
+ preferencesRepository: com.streamvault.domain.settings.SettingsPreferences
): Flow<Map<ContentType, Set<Long>>> {
return combine(
preferencesRepository.getHiddenCategoryIds(providerId, ContentType.LIVE),
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsGuideDefaultCategoryBindings.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsGuideDefaultCategoryBindings.kt
index b1139832..b235da27 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsGuideDefaultCategoryBindings.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsGuideDefaultCategoryBindings.kt
@@ -1,7 +1,7 @@
package com.streamvault.feature.settings.presentation
import com.streamvault.domain.policy.applyProviderCategoryDisplayPreferences
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.domain.model.ActiveLiveSource
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.ContentType
@@ -20,7 +20,7 @@ import kotlinx.coroutines.flow.flowOf
fun observeGuideDefaultCategoryOptions(
combinedM3uRepository: CombinedM3uRepository,
channelRepository: ChannelRepository,
- preferencesRepository: PreferencesRepository,
+ preferencesRepository: SettingsPreferences,
getCustomCategories: GetCustomCategories
): Flow<List<Category>> {
return combinedM3uRepository.getActiveLiveSource().flatMapLatest { activeSource ->
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsObserverRegistrations.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsObserverRegistrations.kt
index 030f5b8a..04d75db0 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsObserverRegistrations.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsObserverRegistrations.kt
@@ -3,7 +3,7 @@ package com.streamvault.feature.settings.presentation
import android.content.Context
import com.streamvault.feature.settings.api.SettingsAppUpdatePort
import com.streamvault.data.local.dao.ProgramDao
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.domain.manager.RecordingManager
import com.streamvault.domain.model.RecordingItem
import com.streamvault.domain.repository.CategoryRepository
@@ -25,7 +25,7 @@ import kotlinx.coroutines.launch
internal fun registerSettingsAppUpdateObservers(
scope: CoroutineScope,
- preferencesRepository: PreferencesRepository,
+ preferencesRepository: SettingsPreferences,
appUpdateActions: SettingsAppUpdateActions,
appUpdatePort: SettingsAppUpdatePort,
uiState: MutableStateFlow<SettingsUiState>
@@ -100,7 +100,7 @@ internal fun registerCombinedProfileObservers(
internal fun registerRecordingObservers(
scope: CoroutineScope,
recordingManager: RecordingManager,
- preferencesRepository: PreferencesRepository,
+ preferencesRepository: SettingsPreferences,
uiState: MutableStateFlow<SettingsUiState>
) {
scope.launch {
@@ -137,7 +137,7 @@ internal fun registerRecordingObservers(
internal fun registerEpgObservers(
scope: CoroutineScope,
epgSourceRepository: EpgSourceRepository,
- preferencesRepository: PreferencesRepository,
+ preferencesRepository: SettingsPreferences,
uiState: MutableStateFlow<SettingsUiState>
) {
scope.launch {
@@ -160,7 +160,7 @@ internal fun registerDerivedStateObservers(
seriesRepository: SeriesRepository,
programDao: ProgramDao,
application: Context,
- preferencesRepository: PreferencesRepository,
+ preferencesRepository: SettingsPreferences,
activeProviderIdFlow: Flow<Long?>,
categoryRepository: CategoryRepository,
combinedM3uRepository: CombinedM3uRepository,
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsOperationalModels.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsOperationalModels.kt
index e6baee8f..47af2797 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsOperationalModels.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsOperationalModels.kt
@@ -1,7 +1,7 @@
package com.streamvault.feature.settings.presentation
import com.streamvault.data.local.entity.XtreamLiveOnboardingStateEntity
-import com.streamvault.data.preferences.DatabaseMaintenanceSnapshot
+import com.streamvault.domain.settings.DatabaseMaintenanceSnapshot
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.CategorySortMode
import com.streamvault.domain.model.ContentType
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsProviderActions.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsProviderActions.kt
index 718e686f..4c56b5ea 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsProviderActions.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsProviderActions.kt
@@ -16,7 +16,7 @@ import com.streamvault.domain.usecase.SyncProviderCommand
import com.streamvault.domain.usecase.SyncProviderResult
import com.streamvault.domain.util.PersistedTimestampPolicy
import com.streamvault.data.sync.ProviderSyncCommands
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
@@ -34,7 +34,7 @@ internal fun shouldAutoSyncProvider(
internal class SettingsProviderActions(
private val providerRepository: ProviderRepository,
private val combinedM3uRepository: CombinedM3uRepository,
- private val preferencesRepository: PreferencesRepository,
+ private val preferencesRepository: SettingsPreferences,
private val syncProvider: SyncProvider,
private val syncManager: ProviderSyncCommands,
private val syncMetadataRepository: SyncMetadataRepository,
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsStateBindings.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsStateBindings.kt
index 258b9641..0544ea44 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsStateBindings.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsStateBindings.kt
@@ -8,7 +8,7 @@ import com.streamvault.domain.model.VodViewMode
import com.streamvault.domain.model.AppHomeDashboardShelf
import com.streamvault.domain.model.AppLandingDestination
import com.streamvault.domain.model.AppTopLevelDestination
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.domain.model.AppTimeFormat
import com.streamvault.domain.model.AudioOutputPreference
import com.streamvault.domain.model.ChannelNumberingMode
@@ -32,7 +32,7 @@ import kotlinx.coroutines.flow.combine
fun observeSettingsPreferenceSnapshot(
providerRepository: ProviderRepository,
activeProviderIdFlow: Flow<Long?>,
- preferencesRepository: PreferencesRepository
+ preferencesRepository: SettingsPreferences
): Flow<SettingsPreferenceSnapshot> {
return combine(
providerRepository.getProviders(),
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsViewModel.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsViewModel.kt
index 4561a898..dc5121a2 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsViewModel.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsViewModel.kt
@@ -17,7 +17,7 @@ import com.streamvault.data.local.dao.ProgramDao
import com.streamvault.data.local.dao.XtreamIndexJobDao
import com.streamvault.data.local.dao.XtreamLiveOnboardingDao
import com.streamvault.data.local.entity.XtreamIndexJobEntity
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.data.sync.ProviderSyncCommands
import com.streamvault.data.sync.SyncRepairSection
import com.streamvault.domain.model.VodCategoryLoadMode
@@ -104,7 +104,7 @@ class SettingsViewModel @Inject constructor(
private val movieRepository: MovieRepository,
private val seriesRepository: SeriesRepository,
private val programDao: ProgramDao,
- private val preferencesRepository: PreferencesRepository,
+ private val preferencesRepository: SettingsPreferences,
private val internetSpeedTestRunner: InternetSpeedTestRunner,
private val backupManager: BackupManager,
private val backupRestoreStatusStore: BackupRestoreStatusStore,
diff --git a/feature/settings/src/test/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModelTest.kt b/feature/settings/src/test/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModelTest.kt
index 93e0f387..27fbdd6f 100644
--- a/feature/settings/src/test/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModelTest.kt
+++ b/feature/settings/src/test/java/com/streamvault/feature/settings/parental/ParentalControlGroupViewModelTest.kt
@@ -2,7 +2,7 @@ package com.streamvault.feature.settings.parental
import androidx.lifecycle.SavedStateHandle
import com.google.common.truth.Truth.assertThat
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.repository.CategoryRepository
@@ -18,7 +18,7 @@ import org.mockito.kotlin.whenever
class ParentalControlGroupViewModelTest {
private val categoryRepository: CategoryRepository = mock()
- private val preferencesRepository: PreferencesRepository = mock()
+ private val preferencesRepository: SettingsPreferences = mock()
@Test
fun adultCategoryRemainsProtectedWhenProtectionIsToggled() = runTest {
diff --git a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActionsTest.kt b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActionsTest.kt
index d8b26a15..ec06c1df 100644
--- a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActionsTest.kt
+++ b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsAppUpdateActionsTest.kt
@@ -2,7 +2,7 @@ package com.streamvault.feature.settings.presentation
import android.content.Context
import com.google.common.truth.Truth.assertThat
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.feature.settings.api.SettingsAppUpdatePort
import com.streamvault.feature.settings.api.SettingsReleaseInfo
import com.streamvault.feature.settings.api.SettingsUpdateDownloadState
@@ -25,7 +25,7 @@ class SettingsAppUpdateActionsTest {
@Test
fun `failed check records failure without replacing cached release`() = runTest(StandardTestDispatcher()) {
val application = mock<Context>()
- val preferences = mock<PreferencesRepository>()
+ val preferences = mock<SettingsPreferences>()
val updatePort = mock<SettingsAppUpdatePort>()
val uiState = MutableStateFlow(SettingsUiState())
whenever(updatePort.fetchLatestRelease()).thenReturn(Result.error("HTTP 500"))
diff --git a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsPreferencesContractTest.kt b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsPreferencesContractTest.kt
new file mode 100644
index 00000000..3aa390f0
--- /dev/null
+++ b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsPreferencesContractTest.kt
@@ -0,0 +1,89 @@
+package com.streamvault.feature.settings.presentation
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.Category
+import com.streamvault.domain.model.CategorySortMode
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.Result
+import com.streamvault.domain.repository.CategoryRepository
+import com.streamvault.domain.settings.SettingsPreferences
+import com.streamvault.feature.settings.api.SettingsAppUpdatePort
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SettingsPreferencesContractTest {
+ @Test
+ fun `update actions accept preferences contract and persist failed outcome`() = runTest {
+ val fake = FakeSettingsPreferences()
+ val preferences: SettingsPreferences = fake
+ val updatePort = mock<SettingsAppUpdatePort>()
+ whenever(updatePort.fetchLatestRelease()).thenReturn(Result.error("HTTP 503"))
+ val state = MutableStateFlow(SettingsUiState())
+ val actions = SettingsAppUpdateActions(mock(), preferences, updatePort, state)
+
+ actions.checkForAppUpdates(
+ scope = backgroundScope,
+ manual = false,
+ isRemoteVersionNewer = { _, _, _ -> false }
+ )
+ testScheduler.runCurrent()
+
+ assertThat(state.value.appUpdate.errorMessage).isEqualTo("HTTP 503")
+ assertThat(state.value.isCheckingForUpdates).isFalse()
+ assertThat(fake.outcomes).containsExactly("ATTEMPTED", "FAILURE: HTTP 503").inOrder()
+ assertThat(fake.attemptTimestamp).isNotNull()
+ assertThat(fake.failureTimestamp).isEqualTo(fake.attemptTimestamp)
+ }
+
+ @Test
+ fun `category observer accepts preferences contract and filters hidden categories`() = runTest {
+ val preferences: SettingsPreferences = FakeSettingsPreferences()
+ val categories = mock<CategoryRepository>()
+ val hidden = Category(id = 11L, name = "Hidden", type = ContentType.LIVE)
+ whenever(categories.getCategories(7L)).thenReturn(
+ flowOf(listOf(hidden, Category(id = 12L, name = "Visible")))
+ )
+
+ val snapshot = observeCategoryManagement(flowOf(7L), preferences, categories).first()
+
+ assertThat(snapshot.hiddenCategories).containsExactly(hidden)
+ assertThat(snapshot.categorySortModes).containsExactly(
+ ContentType.LIVE, CategorySortMode.DEFAULT,
+ ContentType.MOVIE, CategorySortMode.DEFAULT,
+ ContentType.SERIES, CategorySortMode.DEFAULT
+ )
+ }
+
+ // Only the exercised preferences need state; unused contract members delegate to a mock.
+ private class FakeSettingsPreferences : SettingsPreferences by mock<SettingsPreferences>() {
+ var attemptTimestamp: Long? = null
+ var failureTimestamp: Long? = null
+ val outcomes = mutableListOf<String?>()
+
+ override suspend fun setLastAppUpdateAttemptTimestamp(timestampMs: Long?) {
+ attemptTimestamp = timestampMs
+ }
+
+ override suspend fun setLastAppUpdateFailureTimestamp(timestampMs: Long?) {
+ failureTimestamp = timestampMs
+ }
+
+ override suspend fun setLastAppUpdateOutcome(outcome: String?) {
+ outcomes += outcome
+ }
+
+ override fun getCategorySortMode(providerId: Long, type: ContentType): Flow<CategorySortMode> =
+ flowOf(CategorySortMode.DEFAULT)
+
+ override fun getHiddenCategoryIds(providerId: Long, type: ContentType): Flow<Set<Long>> =
+ flowOf(if (providerId == 7L && type == ContentType.LIVE) setOf(11L) else emptySet())
+ }
+}
diff --git a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsProviderActionsTest.kt b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsProviderActionsTest.kt
index 7fbd109f..c2acdc74 100644
--- a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsProviderActionsTest.kt
+++ b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsProviderActionsTest.kt
@@ -1,7 +1,7 @@
package com.streamvault.feature.settings.presentation
import com.google.common.truth.Truth.assertThat
-import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.settings.SettingsPreferences
import com.streamvault.data.sync.SyncManager
import com.streamvault.domain.model.ActiveLiveSource
import com.streamvault.domain.model.LegacyProvider as Provider
@@ -31,7 +31,7 @@ class SettingsProviderActionsTest {
private val providerRepository: ProviderRepository = mock()
private val combinedM3uRepository: CombinedM3uRepository = mock()
- private val preferencesRepository: PreferencesRepository = mock()
+ private val preferencesRepository: SettingsPreferences = mock()
private val syncProvider: SyncProvider = mock()
private val syncManager: SyncManager = mock()
private val syncMetadataRepository: SyncMetadataRepository = mock()