StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
feat(trakt): add account, sync, and discovery integration
David Nashashade161441fce
diff --git a/.github/workflows/beta.yml b/.github/workflows/beta.ymlindex 98695c02..078844db 100644--- a/.github/workflows/beta.yml+++ b/.github/workflows/beta.yml@@ -13,6 +13,9 @@ jobs:build-beta:if: github.ref == 'refs/heads/develop'runs-on: ubuntu-latest+ env:+ TRAKT_CLIENT_ID: ${{ secrets.TRAKT_CLIENT_ID }}+ TRAKT_REDIRECT_URI: ${{ vars.TRAKT_REDIRECT_URI }}steps:- uses: actions/checkout@v4diff --git a/.github/workflows/release.yml b/.github/workflows/release.ymlindex f7893ade..9fd93577 100644--- a/.github/workflows/release.yml+++ b/.github/workflows/release.yml@@ -9,6 +9,9 @@ permissions:jobs:build:runs-on: ubuntu-latest+ env:+ TRAKT_CLIENT_ID: ${{ secrets.TRAKT_CLIENT_ID }}+ TRAKT_REDIRECT_URI: ${{ vars.TRAKT_REDIRECT_URI }}outputs:version_name: ${{ steps.app_version.outputs.version_name }}version_code: ${{ steps.app_version.outputs.version_code }}diff --git a/app/build.gradle.kts b/app/build.gradle.ktsindex dc33909f..56426455 100644--- a/app/build.gradle.kts+++ b/app/build.gradle.kts@@ -1,4 +1,5 @@import java.util.Properties+import java.net.URIimport java.io.FileInputStreamimport java.security.KeyStoreimport java.security.MessageDigest@@ -38,6 +39,12 @@ if (localPropertiesFile.exists()) {fun localProp(key: String): String = localProperties.getProperty(key, "")+// Public app configuration; OAuth user credentials are never build inputs.+val traktClientId = providers.environmentVariable("TRAKT_CLIENT_ID").orNull ?: localProp("trakt.client.id")+val traktRedirectUri = providers.environmentVariable("TRAKT_REDIRECT_URI").orNull ?: localProp("trakt.redirect.uri")+val traktCallback = runCatching { URI(traktRedirectUri) }.getOrNull()+fun buildStringLiteral(value: String): String = "\"" + value.replace("\\", "\\\\").replace("\"", "\\\"") + "\""+fun computeOfficialSigningCertSha256(): String {if (!keystorePropertiesFile.exists()) return ""@@ -71,6 +78,10 @@ android {versionCode = 21versionName = "1.0.19"testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"+ buildConfigField("String", "TRAKT_CLIENT_ID", buildStringLiteral(traktClientId))+ buildConfigField("String", "TRAKT_REDIRECT_URI", buildStringLiteral(traktRedirectUri))+ manifestPlaceholders["traktCallbackHost"] = traktCallback?.host ?: "trakt-unconfigured.invalid"+ manifestPlaceholders["traktCallbackPath"] = traktCallback?.rawPath?.takeIf(String::isNotBlank) ?: "/oauth/trakt/callback"providers.gradleProperty("compatApi").orNull?.let { expectedApi ->testInstrumentationRunnerArguments["expected_api"] = expectedApi}@@ -533,6 +544,7 @@ dependencies {testImplementation(libs.coroutines.test)testImplementation(libs.mockito.kotlin)testImplementation(libs.robolectric)+ testImplementation(libs.okhttp.mockwebserver)androidTestImplementation(composeBom)androidTestImplementation("androidx.compose.ui:ui-test-junit4")diff --git a/app/proguard-rules.pro b/app/proguard-rules.proindex 59d35773..5eba5f5c 100644--- a/app/proguard-rules.pro+++ b/app/proguard-rules.pro@@ -43,6 +43,10 @@-keep class * implements com.google.gson.JsonDeserializer# Keep fields that GSON accesses via reflection-keepclassmembers class com.streamvault.data.remote.** { <fields>; }+# OAuth records must retain their schema and reflective constructors across releases.+-keep class com.streamvault.data.trakt.TraktTokens { *; }+-keep class com.streamvault.data.trakt.TraktPendingLogin { *; }+-keep class com.streamvault.data.trakt.TraktStoredSession { *; }# ── Room ────────────────────────────────────────────────────-keep class * extends androidx.room.RoomDatabasediff --git a/app/src/androidTest/java/com/streamvault/app/trakt/TraktAccountRecoveryInstrumentationTest.kt b/app/src/androidTest/java/com/streamvault/app/trakt/TraktAccountRecoveryInstrumentationTest.ktnew file mode 100644index 00000000..48c943d6--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/trakt/TraktAccountRecoveryInstrumentationTest.kt@@ -0,0 +1,93 @@+package com.streamvault.app.trakt++import android.content.ContextWrapper+import androidx.test.ext.junit.runners.AndroidJUnit4+import androidx.test.platform.app.InstrumentationRegistry+import com.streamvault.data.security.AndroidKeystoreCredentialCrypto+import com.streamvault.data.trakt.EncryptedTraktTokenStore+import com.streamvault.data.trakt.TraktApi+import com.streamvault.data.trakt.TraktAuthService+import com.streamvault.data.trakt.TraktConfig+import com.streamvault.data.trakt.TraktTokens+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Assert.assertFalse+import org.junit.Assert.assertTrue+import org.junit.Test+import org.junit.runner.RunWith+import java.io.File+import java.util.UUID++/** Real Android encrypted storage with synthetic OAuth responses; no real account changes. */+@RunWith(AndroidJUnit4::class)+class TraktAccountRecoveryInstrumentationTest {+ @Test+ fun recreatedLoginDenialCancellationAndLateCallbacks() = runBlocking {+ val target = InstrumentationRegistry.getInstrumentation().targetContext+ val directory = File(target.cacheDir, "trakt-recovery-${UUID.randomUUID()}")+ assertTrue(directory.mkdirs())+ val context = object : ContextWrapper(target) {+ override fun getNoBackupFilesDir(): File = directory+ }+ val config = TraktConfig("synthetic-client", "https://example.org/oauth/trakt/callback")+ val now = System.currentTimeMillis() / 1000+ var exchanges = 0+ val api = object : TraktApi {+ override suspend fun exchange(code: String, verifier: String): TraktTokens {+ exchanges+++ assertTrue(verifier.isNotBlank())+ return TraktTokens("synthetic-access", "synthetic-refresh", now, 3600)+ }+ override suspend fun refresh(refreshToken: String): TraktTokens = error("Unexpected refresh")+ override suspend fun username(accessToken: String): String = "synthetic-user"+ }+ fun store() = EncryptedTraktTokenStore(context, AndroidKeystoreCredentialCrypto(target))+ fun service() = TraktAuthService(config, store(), api)+ fun callback(state: String, query: String = "code=synthetic-code") =+ "${config.redirectUri}?state=$state&$query"+ try {+ // Pending state/verifier survive replacement of both service and disk-store instance.+ service().beginSignIn()+ val pending = requireNotNull(store().read().pending)+ val record = File(directory, "trakt_session").readText()+ assertTrue(record.startsWith("enc:v1:"))+ assertFalse(record.contains(pending.verifier))+ val recreated = service()+ recreated.load()+ assertTrue(recreated.state.value.connecting)+ recreated.completeSignIn(callback(pending.state))+ assertTrue(recreated.state.value.connected)+ assertEquals("synthetic-user", recreated.state.value.username)+ assertEquals(1, exchanges)+ recreated.disconnect()+ val disconnected = service()+ disconnected.load()+ assertFalse(disconnected.state.value.connected)+ disconnected.completeSignIn(callback(pending.state))+ assertFalse(disconnected.state.value.connected)+ assertEquals(1, exchanges)++ disconnected.beginSignIn()+ val deniedState = requireNotNull(store().read().pending).state+ disconnected.completeSignIn(callback(deniedState, "error=access_denied"))+ assertFalse(disconnected.state.value.connected)+ assertFalse(disconnected.state.value.connecting)+ assertTrue(disconnected.state.value.message == null)+ assertEquals(1, exchanges)++ disconnected.beginSignIn()+ val cancelledState = requireNotNull(store().read().pending).state+ disconnected.cancelSignIn()+ val afterCancel = service()+ afterCancel.load()+ afterCancel.completeSignIn(callback(cancelledState))+ assertFalse(afterCancel.state.value.connected)+ assertFalse(afterCancel.state.value.connecting)+ assertTrue(afterCancel.state.value.message == null)+ assertEquals(1, exchanges)+ assertFalse(File(directory, "trakt_session").exists())+ } finally {+ directory.deleteRecursively()+ }+ }+}diff --git a/app/src/androidTest/java/com/streamvault/app/trakt/TraktLiveAccountInstrumentationTest.kt b/app/src/androidTest/java/com/streamvault/app/trakt/TraktLiveAccountInstrumentationTest.ktnew file mode 100644index 00000000..68c6549d--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/trakt/TraktLiveAccountInstrumentationTest.kt@@ -0,0 +1,72 @@+package com.streamvault.app.trakt++import androidx.test.ext.junit.runners.AndroidJUnit4+import androidx.test.platform.app.InstrumentationRegistry+import com.streamvault.app.BuildConfig+import com.streamvault.data.security.AndroidKeystoreCredentialCrypto+import com.streamvault.data.trakt.EncryptedTraktTokenStore+import com.streamvault.data.trakt.TraktApi+import com.streamvault.data.trakt.TraktApiClient+import com.streamvault.data.trakt.TraktAuthService+import com.streamvault.data.trakt.TraktConfig+import com.streamvault.data.trakt.TraktTokens+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import org.junit.Assert.assertEquals+import org.junit.Assert.assertTrue+import org.junit.Assume.assumeTrue+import org.junit.Test+import org.junit.runner.RunWith+import java.io.File+import java.util.concurrent.TimeUnit++/** Explicitly opt in on an isolated, signed-in device; never run in general CI. */+@RunWith(AndroidJUnit4::class)+class TraktLiveAccountInstrumentationTest {+ @Test+ fun rotatesRealTokenPairAndReloadsEncryptedSession() = runBlocking {+ assumeTrue("Requires explicit live_trakt opt-in",+ InstrumentationRegistry.getArguments().getString("live_trakt") == "true")+ val context = InstrumentationRegistry.getInstrumentation().targetContext+ val config = TraktConfig(BuildConfig.TRAKT_CLIENT_ID, BuildConfig.TRAKT_REDIRECT_URI)+ assertTrue("Trakt must be configured", config.configured)+ fun store() = EncryptedTraktTokenStore(context, AndroidKeystoreCredentialCrypto(context))+ val before = store().read().tokens+ assertTrue("Sign in on the isolated device first", before != null)+ val original = requireNotNull(before)+ val client = OkHttpClient.Builder().connectTimeout(20, TimeUnit.SECONDS)+ .readTimeout(20, TimeUnit.SECONDS).callTimeout(30, TimeUnit.SECONDS)+ .retryOnConnectionFailure(false).followRedirects(false).followSslRedirects(false).build()+ val productionApi = TraktApiClient(config, client,+ userAgent = "StreamVault/${BuildConfig.VERSION_NAME}")+ var refreshCount = 0+ val countedApi = object : TraktApi by productionApi {+ override suspend fun refresh(refreshToken: String): TraktTokens {+ refreshCount+++ return productionApi.refresh(refreshToken)+ }+ }+ // Expire only the old pair in memory. Production persists/rotates the real pair.+ val service = TraktAuthService(config, store(), countedApi,+ now = { original.createdAt + original.expiresIn })+ service.load()+ assertEquals("Exactly one refresh is allowed", 1, refreshCount)+ assertTrue("Account must remain connected", service.state.value.connected)+ assertTrue("Profile must load", !service.state.value.username.isNullOrBlank())+ assertTrue("No account error expected", service.state.value.message == null)+ val after = store().read().tokens+ assertTrue("New pair must be persisted", after != null)+ val rotated = requireNotNull(after)+ // Boolean assertions ensure failure output cannot include either credential.+ assertTrue("Access token must rotate", original.accessToken != rotated.accessToken)+ assertTrue("Refresh token must rotate", original.refreshToken != rotated.refreshToken)+ assertTrue("Record must be encrypted",+ File(context.noBackupFilesDir, "trakt_session").readText().startsWith("enc:v1:"))+ val reloaded = TraktAuthService(config, store(), countedApi)+ reloaded.load()+ assertTrue("Reloaded account must remain connected", reloaded.state.value.connected)+ assertTrue("Reloaded profile must match", reloaded.state.value.username == service.state.value.username)+ assertTrue("Reload must have no error", reloaded.state.value.message == null)+ assertEquals("Reload must reuse the new pair", 1, refreshCount)+ }+}diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xmlindex 76289309..21969d46 100644--- a/app/src/main/AndroidManifest.xml+++ b/app/src/main/AndroidManifest.xml@@ -122,6 +122,19 @@</intent-filter></activity>+ <activity+ android:name=".trakt.TraktCallbackActivity"+ android:exported="true"+ android:excludeFromRecents="true"+ android:theme="@style/Theme.StreamVault">+ <intent-filter android:autoVerify="true">+ <action android:name="android.intent.action.VIEW" />+ <category android:name="android.intent.category.DEFAULT" />+ <category android:name="android.intent.category.BROWSABLE" />+ <data android:scheme="https" android:host="${traktCallbackHost}" android:path="${traktCallbackPath}" />+ </intent-filter>+ </activity>+<activityandroid:name=".cast.CastRouteChooserActivity"android:exported="false"diff --git a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt b/app/src/main/java/com/streamvault/app/di/RepositoryModule.ktindex b1588fd1..1addcca1 100644--- a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt+++ b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt@@ -34,6 +34,7 @@ import com.streamvault.domain.provider.ProviderSourceRegistryimport com.streamvault.domain.provider.PlayerPlaybackResolverimport com.streamvault.domain.settings.PlayerPreferencesimport com.streamvault.domain.settings.SettingsPreferences+import com.streamvault.domain.trakt.TraktFeaturePreferencesimport com.streamvault.app.playback.AppPlayerPlaybackResolverimport com.streamvault.app.plugins.StreamVaultPluginManagerimport dagger.Binds@@ -130,6 +131,9 @@ abstract class RepositoryModule {@Binds @Singletonabstract fun bindSettingsPreferences(impl: PreferencesRepository): SettingsPreferences+ @Binds @Singleton+ abstract fun bindTraktFeaturePreferences(impl: PreferencesRepository): TraktFeaturePreferences+@Binds @Singletonabstract fun bindPlayerPreferences(impl: PreferencesRepository): PlayerPreferencesdiff --git a/app/src/main/java/com/streamvault/app/di/TraktModule.kt b/app/src/main/java/com/streamvault/app/di/TraktModule.ktnew file mode 100644index 00000000..c5657748--- /dev/null+++ b/app/src/main/java/com/streamvault/app/di/TraktModule.kt@@ -0,0 +1,86 @@+package com.streamvault.app.di++import android.content.Context+import com.streamvault.app.BuildConfig+import com.streamvault.data.security.CredentialCrypto+import com.streamvault.data.trakt.EncryptedTraktTokenStore+import com.streamvault.data.trakt.TraktApiClient+import com.streamvault.data.trakt.TraktAuthService+import com.streamvault.data.trakt.TraktConfig+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktScrobbler+import com.streamvault.domain.trakt.TraktHistorySource+import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistSource+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoritesSource+import com.streamvault.domain.trakt.TraktFavoriteImporter+import com.streamvault.domain.trakt.TraktRatings+import com.streamvault.domain.trakt.TraktRatingsSource+import com.streamvault.domain.trakt.TraktCustomLists+import com.streamvault.domain.trakt.TraktCustomListsSource+import com.streamvault.domain.trakt.TraktDiscovery+import com.streamvault.domain.trakt.TraktDiscoverySource+import dagger.Module+import dagger.Provides+import dagger.hilt.InstallIn+import dagger.hilt.android.qualifiers.ApplicationContext+import dagger.hilt.components.SingletonComponent+import okhttp3.OkHttpClient+import java.util.concurrent.TimeUnit+import javax.inject.Singleton++@Module+@InstallIn(SingletonComponent::class)+object TraktModule {+ @Provides @Singleton+ fun sync(service: com.streamvault.data.trakt.TraktHistorySyncService): com.streamvault.domain.trakt.TraktHistorySync = service+ @Provides @Singleton+ fun history(account: TraktAccount): TraktHistorySource = account as TraktHistorySource++ @Provides @Singleton+ fun watchlist(service: com.streamvault.data.trakt.TraktWatchlistService): TraktWatchlist = service++ @Provides @Singleton+ fun watchlistSource(account: TraktAccount): TraktWatchlistSource = account as TraktWatchlistSource++ @Provides @Singleton+ fun favorites(service: com.streamvault.data.trakt.TraktFavoritesService): TraktFavorites = service++ @Provides @Singleton+ fun favoriteImporter(service: com.streamvault.data.trakt.TraktFavoriteImporterService): TraktFavoriteImporter = service++ @Provides @Singleton+ fun favoritesSource(account: TraktAccount): TraktFavoritesSource = account as TraktFavoritesSource++ @Provides @Singleton+ fun ratings(service: com.streamvault.data.trakt.TraktRatingsService): TraktRatings = service++ @Provides @Singleton+ fun ratingsSource(account: TraktAccount): TraktRatingsSource = account as TraktRatingsSource++ @Provides @Singleton+ fun customLists(service: com.streamvault.data.trakt.TraktCustomListsService): TraktCustomLists = service++ @Provides @Singleton+ fun customListsSource(account: TraktAccount): TraktCustomListsSource = account as TraktCustomListsSource++ @Provides @Singleton+ fun discovery(service: com.streamvault.data.trakt.TraktDiscoveryService): TraktDiscovery = service++ @Provides @Singleton+ fun discoverySource(account: TraktAccount): TraktDiscoverySource = account as TraktDiscoverySource++ @Provides @Singleton+ fun scrobbler(account: TraktAccount): TraktScrobbler = account as TraktScrobbler++ @Provides @Singleton+ fun account(@ApplicationContext context: Context, crypto: CredentialCrypto): TraktAccount {+ val config = TraktConfig(BuildConfig.TRAKT_CLIENT_ID, BuildConfig.TRAKT_REDIRECT_URI)+ val client = OkHttpClient.Builder().connectTimeout(20, TimeUnit.SECONDS)+ .readTimeout(20, TimeUnit.SECONDS).callTimeout(30, TimeUnit.SECONDS)+ .retryOnConnectionFailure(false).followRedirects(false).followSslRedirects(false).build()+ return TraktAuthService(config, EncryptedTraktTokenStore(context, crypto),+ TraktApiClient(config, client, userAgent = "StreamVault/${BuildConfig.VERSION_NAME}"))+ }+}diff --git a/app/src/main/java/com/streamvault/app/trakt/TraktCallbackActivity.kt b/app/src/main/java/com/streamvault/app/trakt/TraktCallbackActivity.ktnew file mode 100644index 00000000..e13ba005--- /dev/null+++ b/app/src/main/java/com/streamvault/app/trakt/TraktCallbackActivity.kt@@ -0,0 +1,29 @@+package com.streamvault.app.trakt++import android.content.Intent+import android.os.Bundle+import androidx.activity.ComponentActivity+import androidx.lifecycle.lifecycleScope+import com.streamvault.app.MainActivity+import com.streamvault.domain.trakt.TraktAccount+import dagger.hilt.android.AndroidEntryPoint+import kotlinx.coroutines.launch+import javax.inject.Inject++/** A dedicated entry point prevents OAuth codes from entering import/playback intent handling. */+@AndroidEntryPoint+class TraktCallbackActivity : ComponentActivity() {+ @Inject lateinit var account: TraktAccount+ override fun onCreate(savedInstanceState: Bundle?) {+ super.onCreate(savedInstanceState)+ lifecycleScope.launch {+ try {+ intent.dataString?.let { account.completeSignIn(it) }+ startActivity(Intent(this@TraktCallbackActivity, MainActivity::class.java)+ .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP))+ } finally {+ finish()+ }+ }+ }+}diff --git a/app/src/test/java/com/streamvault/app/trakt/TraktPlaybackIntegrationTest.kt b/app/src/test/java/com/streamvault/app/trakt/TraktPlaybackIntegrationTest.ktnew file mode 100644index 00000000..9fdd3bb7--- /dev/null+++ b/app/src/test/java/com/streamvault/app/trakt/TraktPlaybackIntegrationTest.kt@@ -0,0 +1,102 @@+package com.streamvault.app.trakt++import android.app.Application+import android.content.ContextWrapper+import com.google.gson.Gson+import com.google.gson.JsonObject+import com.streamvault.data.security.AndroidKeystoreCredentialCrypto+import com.streamvault.data.trakt.*+import com.streamvault.domain.trakt.*+import com.streamvault.feature.playback.player.PlayerTraktCoordinator+import kotlinx.coroutines.*+import kotlinx.coroutines.channels.Channel+import kotlinx.coroutines.flow.first+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.*+import org.junit.Assert.*+import org.junit.Test+import org.junit.runner.RunWith+import org.robolectric.RobolectricTestRunner+import org.robolectric.RuntimeEnvironment+import org.robolectric.annotation.Config+import java.io.File+import java.util.UUID+import java.util.concurrent.TimeUnit++/** Synthetic account + HTTP server; no real Trakt requests or watched-history changes. */+@RunWith(RobolectricTestRunner::class)+@Config(application = Application::class, sdk = [34])+class TraktPlaybackIntegrationTest {+ @Test fun playerTransitionsReachAuthenticatedMovieAndResolvedEpisodeRequests() = runBlocking {+ val target = RuntimeEnvironment.getApplication()+ val directory = File(target.cacheDir, "trakt-playback-${UUID.randomUUID()}")+ assertTrue(directory.mkdirs())+ val context = object : ContextWrapper(target) {+ override fun getNoBackupFilesDir(): File = directory+ }+ val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)+ try {+ MockWebServer().use { server ->+ server.dispatcher = object : Dispatcher() {+ override fun dispatch(request: RecordedRequest): MockResponse = when (request.path) {+ "/users/settings" -> MockResponse().setBody("""{"user":{"username":"synthetic-viewer"}}""")+ "/search/tmdb/1396?type=show" -> MockResponse().setBody("""[{"type":"show","show":{"ids":{"tmdb":1396,"trakt":1}}}]""")+ "/shows/1/seasons/2/episodes/3" -> MockResponse().setBody("""{"season":2,"number":3,"ids":{"trakt":123}}""")+ "/scrobble/start", "/scrobble/pause", "/scrobble/stop" -> MockResponse().setResponseCode(201).setBody("{}")+ else -> MockResponse().setResponseCode(404)+ }+ }+ val store = EncryptedTraktTokenStore(context, AndroidKeystoreCredentialCrypto(target))+ val now = System.currentTimeMillis() / 1000+ store.write(TraktStoredSession(TraktTokens("synthetic-access", "synthetic-refresh", now, 3600)))+ val account = TraktAuthService(TraktConfig("synthetic-client", "https://example.org/callback"), store,+ TraktApiClient(TraktConfig("synthetic-client", "https://example.org/callback"),+ OkHttpClient.Builder().callTimeout(5, TimeUnit.SECONDS).build(), server.url("/")))+ val completed = Channel<Pair<TraktScrobbleEvent, TraktScrobbleOutcome>>(Channel.UNLIMITED)+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ val outcome = account.send(event)+ completed.send(event to outcome)+ return outcome+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, scope)+ withTimeout(10_000) { account.state.first { it.username == "synthetic-viewer" } }+ assertEquals("/users/settings", server.takeRequest(1, TimeUnit.SECONDS)?.path)+ val movie = TraktMediaIdentity.MovieId(603)+ val episode = TraktMediaIdentity.EpisodeId(1396, 2, 3)+ suspend fun sent(action: TraktScrobbleAction, identity: TraktMediaIdentity) {+ val result = withTimeout(10_000) { completed.receive() }+ assertEquals(TraktScrobbleOutcome.SENT, result.second)+ assertEquals(action, result.first.action)+ assertEquals(identity, result.first.media)+ }+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ sent(TraktScrobbleAction.START, movie)+ coordinator.report(1, movie, TraktPlaybackPhase.PAUSED, 200, 1000)+ sent(TraktScrobbleAction.PAUSE, movie)+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 200, 1000)+ sent(TraktScrobbleAction.START, movie)+ coordinator.report(2, episode, TraktPlaybackPhase.PLAYING, 50, 1000)+ sent(TraktScrobbleAction.STOP, movie)+ sent(TraktScrobbleAction.START, episode)+ coordinator.report(2, episode, TraktPlaybackPhase.ENDED, 1000, 1000)+ sent(TraktScrobbleAction.STOP, episode)+ coordinator.close()++ val requests = List(8) { requireNotNull(server.takeRequest(1, TimeUnit.SECONDS)) }+ assertEquals(listOf("/scrobble/start", "/scrobble/pause", "/scrobble/start", "/scrobble/stop",+ "/search/tmdb/1396?type=show", "/shows/1/seasons/2/episodes/3", "/scrobble/start", "/scrobble/stop"), requests.map { it.path })+ assertTrue(requests.all { it.getHeader("Authorization") == "Bearer synthetic-access" })+ assertTrue(requests.all { it.getHeader("trakt-api-key") == "synthetic-client" })+ val lastBody = Gson().fromJson(requests.last().body.readUtf8(), JsonObject::class.java)+ assertEquals(123, lastBody.getAsJsonObject("episode").getAsJsonObject("ids")["trakt"].asInt)+ assertEquals(100.0, lastBody["progress"].asDouble, .001)+ assertTrue(File(directory, "trakt_session").readText().startsWith("enc:v1:"))+ }+ } finally {+ scope.cancel()+ directory.deleteRecursively()+ }+ }+}diff --git a/core/ui/src/main/java/com/streamvault/core/ui/components/TvOutlinedTextField.kt b/core/ui/src/main/java/com/streamvault/core/ui/components/TvOutlinedTextField.ktnew file mode 100644index 00000000..83cf60c1--- /dev/null+++ b/core/ui/src/main/java/com/streamvault/core/ui/components/TvOutlinedTextField.kt@@ -0,0 +1,122 @@+package com.streamvault.core.ui.components++import androidx.activity.compose.BackHandler+import androidx.compose.foundation.clickable+import androidx.compose.foundation.focusable+import androidx.compose.foundation.layout.Box+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.text.KeyboardActions+import androidx.compose.foundation.text.KeyboardOptions+import androidx.compose.material3.OutlinedTextField+import androidx.compose.material3.TextFieldColors+import androidx.compose.runtime.Composable+import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue+import androidx.compose.ui.Modifier+import androidx.compose.ui.focus.FocusRequester+import androidx.compose.ui.focus.focusProperties+import androidx.compose.ui.focus.focusRequester+import androidx.compose.ui.focus.onFocusChanged+import androidx.compose.ui.platform.LocalSoftwareKeyboardController+import com.streamvault.core.ui.device.rememberIsTelevisionDevice+import com.streamvault.core.ui.interaction.mouseClickable++/**+ * An outlined field that stays in D-pad focus mode on TV until the user selects it.+ * This lets focus move through a form without opening the on-screen keyboard for+ * every text field it passes.+ */+@Composable+fun TvOutlinedTextField(+ value: String,+ onValueChange: (String) -> Unit,+ modifier: Modifier = Modifier,+ label: @Composable (() -> Unit)? = null,+ enabled: Boolean = true,+ singleLine: Boolean = false,+ minLines: Int = 1,+ maxLines: Int = Int.MAX_VALUE,+ keyboardOptions: KeyboardOptions = KeyboardOptions.Default,+ keyboardActions: KeyboardActions = KeyboardActions.Default,+ colors: @Composable (containerFocused: Boolean) -> TextFieldColors,+) {+ val isTelevisionDevice = rememberIsTelevisionDevice()+ val keyboardController = LocalSoftwareKeyboardController.current+ val containerFocusRequester = remember { FocusRequester() }+ val inputFocusRequester = remember { FocusRequester() }+ var hasContainerFocus by remember { mutableStateOf(false) }+ var hasInputFocus by remember { mutableStateOf(false) }+ var acceptsInput by remember(isTelevisionDevice) { mutableStateOf(!isTelevisionDevice) }+ var pendingInputActivation by remember { mutableStateOf(false) }++ fun activateInput() {+ if (!enabled) return+ acceptsInput = true+ if (isTelevisionDevice) {+ pendingInputActivation = true+ } else {+ inputFocusRequester.requestFocus()+ keyboardController?.show()+ }+ }++ LaunchedEffect(isTelevisionDevice, enabled, pendingInputActivation) {+ if (!isTelevisionDevice || !enabled || !pendingInputActivation) return@LaunchedEffect+ inputFocusRequester.requestFocus()+ keyboardController?.show()+ pendingInputActivation = false+ }++ BackHandler(enabled = isTelevisionDevice && enabled && acceptsInput) {+ pendingInputActivation = false+ acceptsInput = false+ keyboardController?.hide()+ containerFocusRequester.requestFocus()+ }++ Box(+ modifier = modifier+ .focusRequester(containerFocusRequester)+ .onFocusChanged { hasContainerFocus = enabled && it.isFocused }+ .mouseClickable(enabled = enabled, focusRequester = containerFocusRequester) {+ activateInput()+ }+ .clickable(enabled = enabled, onClick = ::activateInput)+ .focusable(enabled = enabled),+ ) {+ OutlinedTextField(+ value = value,+ onValueChange = onValueChange,+ label = label,+ singleLine = singleLine,+ minLines = minLines,+ maxLines = maxLines,+ enabled = enabled,+ readOnly = isTelevisionDevice && !acceptsInput,+ keyboardOptions = keyboardOptions,+ keyboardActions = keyboardActions,+ modifier = Modifier+ .fillMaxWidth()+ .focusRequester(inputFocusRequester)+ .focusProperties {+ canFocus = enabled && (!isTelevisionDevice || acceptsInput)+ if (isTelevisionDevice && acceptsInput) {+ left = FocusRequester.Cancel+ right = FocusRequester.Cancel+ }+ }+ .onFocusChanged { focusState ->+ val wasInputFocused = hasInputFocus+ hasInputFocus = enabled && focusState.isFocused+ if (!focusState.isFocused && wasInputFocused && isTelevisionDevice) {+ acceptsInput = false+ keyboardController?.hide()+ }+ },+ colors = colors(hasContainerFocus || hasInputFocus),+ )+ }+}diff --git a/data/schemas/com.streamvault.data.local.StreamVaultDatabase/79.json b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/79.jsonnew file mode 100644index 00000000..c6d2b05d--- /dev/null+++ b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/79.json@@ -0,0 +1,7100 @@+{+ "formatVersion": 1,+ "database": {+ "version": 79,+ "identityHash": "5074bfd566d603d838fdd377c95cf973",+ "entities": [+ {+ "tableName": "providers",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `type` TEXT NOT NULL, `is_active` INTEGER NOT NULL, `status` TEXT NOT NULL, `last_synced_at` INTEGER NOT NULL, `created_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "isActive",+ "columnName": "is_active",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncedAt",+ "columnName": "last_synced_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_providers_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_type` ON `${TABLE_NAME}` (`type`)"+ },+ {+ "name": "index_providers_is_active",+ "unique": false,+ "columnNames": [+ "is_active"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_is_active` ON `${TABLE_NAME}` (`is_active`)"+ }+ ]+ },+ {+ "tableName": "provider_configs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `type` TEXT NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `identity_key` TEXT NOT NULL, `encrypted_config_json` TEXT NOT NULL, `guide_source_policy` TEXT NOT NULL, `channel_logo_source_policy` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "identityKey",+ "columnName": "identity_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "encryptedConfigJson",+ "columnName": "encrypted_config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "guideSourcePolicy",+ "columnName": "guide_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelLogoSourcePolicy",+ "columnName": "channel_logo_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_configs_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_configs_identity_key",+ "unique": true,+ "columnNames": [+ "identity_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_identity_key` ON `${TABLE_NAME}` (`identity_key`)"+ },+ {+ "name": "index_provider_configs_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_configs_type` ON `${TABLE_NAME}` (`type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_account_runtime",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `max_connections` INTEGER NOT NULL, `expiration_date` INTEGER, `api_version` TEXT, `allowed_output_formats_json` TEXT NOT NULL, `catalog_layout` TEXT NOT NULL, `catalog_layout_detection_version` INTEGER NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "maxConnections",+ "columnName": "max_connections",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "expirationDate",+ "columnName": "expiration_date",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "apiVersion",+ "columnName": "api_version",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "allowedOutputFormatsJson",+ "columnName": "allowed_output_formats_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayout",+ "columnName": "catalog_layout",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayoutDetectionVersion",+ "columnName": "catalog_layout_detection_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_account_runtime_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_account_runtime_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `quality_options_json` TEXT, `playback_metadata_json` TEXT, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "qualityOptionsJson",+ "columnName": "quality_options_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channels_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_channels_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channels_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_channels_logical_group_id",+ "unique": false,+ "columnNames": [+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_logical_group_id` ON `${TABLE_NAME}` (`logical_group_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id_logical_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id_logical_group_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `logical_group_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_preferences",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `channel_id` INTEGER NOT NULL, `aspect_ratio` TEXT, `audio_video_offset_ms` INTEGER, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`channel_id`) REFERENCES `channels`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "aspectRatio",+ "columnName": "aspect_ratio",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "audioVideoOffsetMs",+ "columnName": "audio_video_offset_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_preferences_channel_id",+ "unique": true,+ "columnNames": [+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_preferences_channel_id` ON `${TABLE_NAME}` (`channel_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "channels",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "channel_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`channels`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "channels",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_UPDATE BEFORE UPDATE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_DELETE BEFORE DELETE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_UPDATE AFTER UPDATE ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_INSERT AFTER INSERT ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "movies",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `added_at` INTEGER NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, `playback_metadata_json` TEXT, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_movies_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movies_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_movies_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_movies_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_movies_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_added_at_release_date_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "added_at",+ "release_date",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_added_at_release_date_name_id` ON `${TABLE_NAME}` (`provider_id`, `added_at`, `release_date`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movies_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`movies`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "movies",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_UPDATE BEFORE UPDATE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_DELETE BEFORE DELETE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_UPDATE AFTER UPDATE ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_INSERT AFTER INSERT ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "series",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, `catalog_origin` TEXT NOT NULL, `episode_playback_template_url` TEXT, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catalogOrigin",+ "columnName": "catalog_origin",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodePlaybackTemplateUrl",+ "columnName": "episode_playback_template_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_series_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_series_provider_id_series_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_series_provider_id_series_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`)"+ },+ {+ "name": "index_series_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_last_modified_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "last_modified",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_last_modified_name_id` ON `${TABLE_NAME}` (`provider_id`, `last_modified`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`series`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "series",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_UPDATE BEFORE UPDATE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_DELETE BEFORE DELETE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_UPDATE AFTER UPDATE ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_INSERT AFTER INSERT ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "episodes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `episode_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `episode_number` INTEGER NOT NULL, `season_number` INTEGER NOT NULL, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `cover_url` TEXT, `plot` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `release_date` TEXT, `series_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`series_id`) REFERENCES `series`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "episodeId",+ "columnName": "episode_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "coverUrl",+ "columnName": "cover_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_episodes_series_id",+ "unique": false,+ "columnNames": [+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_series_id` ON `${TABLE_NAME}` (`series_id`)"+ },+ {+ "name": "index_episodes_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_episodes_provider_id_series_id_episode_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "series_id",+ "episode_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_episodes_provider_id_series_id_episode_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`, `episode_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "series",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "series_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "categories",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_categories_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_categories_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ },+ {+ "name": "index_categories_provider_id_category_id_type",+ "unique": true,+ "columnNames": [+ "provider_id",+ "category_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_categories_provider_id_category_id_type` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `is_adult` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `playback_metadata_json` TEXT, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channel_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `playback_metadata_json` TEXT, `added_at` INTEGER NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movie_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `provider_series_key` TEXT NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `provider_series_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerSeriesKey",+ "columnName": "provider_series_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "provider_series_key"+ ]+ },+ "indices": [+ {+ "name": "index_series_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "category_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `category_id`, `type`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "category_id",+ "type"+ ]+ },+ "indices": [+ {+ "name": "index_category_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_category_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ },+ {+ "name": "index_category_import_stage_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "programs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `title` TEXT NOT NULL, `description` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `genre` TEXT, `category` TEXT, `has_archive` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "hasArchive",+ "columnName": "has_archive",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_programs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_programs_provider_id_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id` ON `${TABLE_NAME}` (`provider_id`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_end_time_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "end_time",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_end_time_channel_id` ON `${TABLE_NAME}` (`provider_id`, `end_time`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_start_time_end_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_programs_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_start_time` ON `${TABLE_NAME}` (`start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`, `end_time`)"+ }+ ]+ },+ {+ "tableName": "favorites",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `position` INTEGER NOT NULL, `group_id` INTEGER, `group_key` INTEGER NOT NULL, `added_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`group_id`) REFERENCES `virtual_groups`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupId",+ "columnName": "group_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_favorites_provider_id_content_id_content_type_group_key",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_id",+ "content_type",+ "group_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_favorites_provider_id_content_id_content_type_group_key` ON `${TABLE_NAME}` (`provider_id`, `content_id`, `content_type`, `group_key`)"+ },+ {+ "name": "index_favorites_provider_id_content_type_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_provider_id_content_type_group_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `group_id`)"+ },+ {+ "name": "index_favorites_group_id_position",+ "unique": false,+ "columnNames": [+ "group_id",+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_group_id_position` ON `${TABLE_NAME}` (`group_id`, `position`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "virtual_groups",+ "onDelete": "SET NULL",+ "onUpdate": "NO ACTION",+ "columns": [+ "group_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "virtual_groups",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `icon_emoji` TEXT, `position` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `content_type` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconEmoji",+ "columnName": "icon_emoji",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_virtual_groups_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_virtual_groups_position",+ "unique": false,+ "columnNames": [+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_position` ON `${TABLE_NAME}` (`position`)"+ },+ {+ "name": "index_virtual_groups_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_content_type` ON `${TABLE_NAME}` (`content_type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "playback_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `poster_url` TEXT, `stream_url` TEXT NOT NULL, `resume_position_ms` INTEGER NOT NULL, `total_duration_ms` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `watched_status` TEXT NOT NULL, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resumePositionMs",+ "columnName": "resume_position_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalDurationMs",+ "columnName": "total_duration_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchedStatus",+ "columnName": "watched_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_history_content_id_content_type_provider_id",+ "unique": true,+ "columnNames": [+ "content_id",+ "content_type",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_history_content_id_content_type_provider_id` ON `${TABLE_NAME}` (`content_id`, `content_type`, `provider_id`)"+ },+ {+ "name": "index_playback_history_last_watched_at",+ "unique": false,+ "columnNames": [+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_last_watched_at` ON `${TABLE_NAME}` (`last_watched_at`)"+ },+ {+ "name": "index_playback_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `content_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_last_watched_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_last_watched_at` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `last_watched_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "tmdb_identity",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tmdb_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `canonical_provider_id` INTEGER NOT NULL, `first_seen_at` INTEGER NOT NULL, PRIMARY KEY(`tmdb_id`, `content_type`), FOREIGN KEY(`canonical_provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "canonicalProviderId",+ "columnName": "canonical_provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "firstSeenAt",+ "columnName": "first_seen_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "tmdb_id",+ "content_type"+ ]+ },+ "indices": [+ {+ "name": "index_tmdb_identity_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_content_type` ON `${TABLE_NAME}` (`content_type`)"+ },+ {+ "name": "index_tmdb_identity_canonical_provider_id",+ "unique": false,+ "columnNames": [+ "canonical_provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_canonical_provider_id` ON `${TABLE_NAME}` (`canonical_provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "canonical_provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "search_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `query` TEXT NOT NULL, `content_scope` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `used_at` INTEGER NOT NULL, `use_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "query",+ "columnName": "query",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentScope",+ "columnName": "content_scope",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "usedAt",+ "columnName": "used_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "useCount",+ "columnName": "use_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_search_history_content_scope_provider_id_used_at",+ "unique": false,+ "columnNames": [+ "content_scope",+ "provider_id",+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_content_scope_provider_id_used_at` ON `${TABLE_NAME}` (`content_scope`, `provider_id`, `used_at`)"+ },+ {+ "name": "index_search_history_used_at",+ "unique": false,+ "columnNames": [+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_used_at` ON `${TABLE_NAME}` (`used_at`)"+ },+ {+ "name": "index_search_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_search_history_query_content_scope_provider_id",+ "unique": true,+ "columnNames": [+ "query",+ "content_scope",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_search_history_query_content_scope_provider_id` ON `${TABLE_NAME}` (`query`, `content_scope`, `provider_id`)"+ }+ ]+ },+ {+ "tableName": "sync_metadata",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `last_live_sync` INTEGER NOT NULL, `last_live_success` INTEGER NOT NULL, `last_movie_sync` INTEGER NOT NULL, `last_series_sync` INTEGER NOT NULL, `last_series_success` INTEGER NOT NULL, `last_epg_sync` INTEGER NOT NULL, `last_epg_success` INTEGER NOT NULL, `last_movie_attempt` INTEGER NOT NULL, `last_movie_success` INTEGER NOT NULL, `last_movie_partial` INTEGER NOT NULL, `live_count` INTEGER NOT NULL, `movie_count` INTEGER NOT NULL, `series_count` INTEGER NOT NULL, `epg_count` INTEGER NOT NULL, `last_sync_status` TEXT NOT NULL, `movie_sync_mode` TEXT NOT NULL, `movie_warnings_count` INTEGER NOT NULL, `movie_catalog_stale` INTEGER NOT NULL, `live_avoid_full_until` INTEGER NOT NULL, `movie_avoid_full_until` INTEGER NOT NULL, `series_avoid_full_until` INTEGER NOT NULL, `live_sequential_failures_remembered` INTEGER NOT NULL, `live_healthy_sync_streak` INTEGER NOT NULL, `movie_parallel_failures_remembered` INTEGER NOT NULL, `movie_healthy_sync_streak` INTEGER NOT NULL, `series_sequential_failures_remembered` INTEGER NOT NULL, `series_healthy_sync_streak` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSync",+ "columnName": "last_live_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSuccess",+ "columnName": "last_live_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSync",+ "columnName": "last_movie_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSync",+ "columnName": "last_series_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSuccess",+ "columnName": "last_series_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSync",+ "columnName": "last_epg_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSuccess",+ "columnName": "last_epg_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieAttempt",+ "columnName": "last_movie_attempt",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSuccess",+ "columnName": "last_movie_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMoviePartial",+ "columnName": "last_movie_partial",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveCount",+ "columnName": "live_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCount",+ "columnName": "movie_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesCount",+ "columnName": "series_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgCount",+ "columnName": "epg_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncStatus",+ "columnName": "last_sync_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieSyncMode",+ "columnName": "movie_sync_mode",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieWarningsCount",+ "columnName": "movie_warnings_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCatalogStale",+ "columnName": "movie_catalog_stale",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveAvoidFullUntil",+ "columnName": "live_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieAvoidFullUntil",+ "columnName": "movie_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesAvoidFullUntil",+ "columnName": "series_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveSequentialFailuresRemembered",+ "columnName": "live_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveHealthySyncStreak",+ "columnName": "live_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieParallelFailuresRemembered",+ "columnName": "movie_parallel_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieHealthySyncStreak",+ "columnName": "movie_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesSequentialFailuresRemembered",+ "columnName": "series_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesHealthySyncStreak",+ "columnName": "series_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_series_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `page_size` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `is_complete` INTEGER NOT NULL, `has_movies` INTEGER NOT NULL, `has_series` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasMovies",+ "columnName": "has_movies",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasSeries",+ "columnName": "has_series",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_catalog_entries",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `raw_item_id` TEXT NOT NULL, `item_type` TEXT NOT NULL, `target_id` INTEGER NOT NULL, `raw_page` INTEGER NOT NULL, `raw_index` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `category_id`, `raw_item_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawItemId",+ "columnName": "raw_item_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "itemType",+ "columnName": "item_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawPage",+ "columnName": "raw_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawIndex",+ "columnName": "raw_index",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_item_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_catalog_entries_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_page",+ "raw_index"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `raw_page`, `raw_index`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_item_type_target_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "item_type",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_item_type_target_id` ON `${TABLE_NAME}` (`provider_id`, `item_type`, `target_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `url` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `last_refresh_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `last_error` TEXT, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `etag` TEXT, `last_modified_header` TEXT, `timezone_policy` TEXT NOT NULL, `timezone_id` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "url",+ "columnName": "url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastRefreshAt",+ "columnName": "last_refresh_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "etag",+ "columnName": "etag",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModifiedHeader",+ "columnName": "last_modified_header",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "timezonePolicy",+ "columnName": "timezone_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "timezoneId",+ "columnName": "timezone_id",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_sources_url",+ "unique": true,+ "columnNames": [+ "url"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_sources_url` ON `${TABLE_NAME}` (`url`)"+ }+ ]+ },+ {+ "tableName": "provider_epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `epg_source_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_epg_sources_provider_id_epg_source_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_epg_sources_provider_id_epg_source_id` ON `${TABLE_NAME}` (`provider_id`, `epg_source_id`)"+ },+ {+ "name": "index_provider_epg_sources_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_epg_sources_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `display_name` TEXT NOT NULL, `normalized_name` TEXT NOT NULL, `icon_url` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "normalizedName",+ "columnName": "normalized_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconUrl",+ "columnName": "icon_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_channels_epg_source_id_xmltv_channel_id",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id_xmltv_channel_id` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`)"+ },+ {+ "name": "index_epg_channels_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_channels_normalized_name",+ "unique": false,+ "columnNames": [+ "normalized_name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_normalized_name` ON `${TABLE_NAME}` (`normalized_name`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_programmes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `title` TEXT NOT NULL, `subtitle` TEXT, `description` TEXT NOT NULL, `category` TEXT, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `episode_info` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "subtitle",+ "columnName": "subtitle",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeInfo",+ "columnName": "episode_info",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_programmes_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_start_time` ON `${TABLE_NAME}` (`start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_epg_mappings",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_channel_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `source_type` TEXT NOT NULL, `epg_source_id` INTEGER, `xmltv_channel_id` TEXT, `match_type` TEXT, `confidence` REAL NOT NULL, `matched_at` INTEGER NOT NULL, `failed_attempts` INTEGER NOT NULL, `source` TEXT, `is_manual_override` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerChannelId",+ "columnName": "provider_channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "matchType",+ "columnName": "match_type",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "confidence",+ "columnName": "confidence",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "matchedAt",+ "columnName": "matched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedAttempts",+ "columnName": "failed_attempts",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "source",+ "columnName": "source",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isManualOverride",+ "columnName": "is_manual_override",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_epg_mappings_provider_id_provider_channel_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "provider_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id_provider_channel_id` ON `${TABLE_NAME}` (`provider_id`, `provider_channel_id`)"+ },+ {+ "name": "index_channel_epg_mappings_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "combined_m3u_profiles",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "combined_m3u_profile_members",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `profile_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`profile_id`) REFERENCES `combined_m3u_profiles`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "profileId",+ "columnName": "profile_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_combined_m3u_profile_members_profile_id",+ "unique": false,+ "columnNames": [+ "profile_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id` ON `${TABLE_NAME}` (`profile_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_profile_id_provider_id",+ "unique": true,+ "columnNames": [+ "profile_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id_provider_id` ON `${TABLE_NAME}` (`profile_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "combined_m3u_profiles",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "profile_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_schedules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `requested_start_ms` INTEGER NOT NULL, `requested_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `enabled` INTEGER NOT NULL, `is_manual` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "requestedStartMs",+ "columnName": "requested_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "requestedEndMs",+ "columnName": "requested_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isManual",+ "columnName": "is_manual",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_schedules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_schedules_enabled_requested_start_ms",+ "unique": false,+ "columnNames": [+ "enabled",+ "requested_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_enabled_requested_start_ms` ON `${TABLE_NAME}` (`enabled`, `requested_start_ms`)"+ },+ {+ "name": "index_recording_schedules_recurring_rule_id",+ "unique": false,+ "columnNames": [+ "recurring_rule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_recurring_rule_id` ON `${TABLE_NAME}` (`recurring_rule_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_runs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `schedule_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `scheduled_start_ms` INTEGER NOT NULL, `scheduled_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `status` TEXT NOT NULL, `source_type` TEXT NOT NULL, `resolved_url` TEXT, `headers_json` TEXT NOT NULL, `user_agent` TEXT, `expiration_time` INTEGER, `provider_label` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `bytes_written` INTEGER NOT NULL, `average_throughput_bps` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `last_progress_at_ms` INTEGER, `failure_category` TEXT NOT NULL, `failure_reason` TEXT, `terminal_at_ms` INTEGER, `started_at_ms` INTEGER, `ended_at_ms` INTEGER, `schedule_enabled` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `alarm_start_at_ms` INTEGER, `alarm_stop_at_ms` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`schedule_id`) REFERENCES `recording_schedules`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "scheduleId",+ "columnName": "schedule_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "scheduledStartMs",+ "columnName": "scheduled_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "scheduledEndMs",+ "columnName": "scheduled_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolvedUrl",+ "columnName": "resolved_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "headersJson",+ "columnName": "headers_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "userAgent",+ "columnName": "user_agent",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "expirationTime",+ "columnName": "expiration_time",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "providerLabel",+ "columnName": "provider_label",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "averageThroughputBytesPerSecond",+ "columnName": "average_throughput_bps",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastProgressAtMs",+ "columnName": "last_progress_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureCategory",+ "columnName": "failure_category",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "terminalAtMs",+ "columnName": "terminal_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "startedAtMs",+ "columnName": "started_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "endedAtMs",+ "columnName": "ended_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "scheduleEnabled",+ "columnName": "schedule_enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "alarmStartAtMs",+ "columnName": "alarm_start_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "alarmStopAtMs",+ "columnName": "alarm_stop_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_runs_schedule_id",+ "unique": false,+ "columnNames": [+ "schedule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_schedule_id` ON `${TABLE_NAME}` (`schedule_id`)"+ },+ {+ "name": "index_recording_runs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_runs_status_scheduled_start_ms",+ "unique": false,+ "columnNames": [+ "status",+ "scheduled_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_status_scheduled_start_ms` ON `${TABLE_NAME}` (`status`, `scheduled_start_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_start_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_start_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_start_at_ms` ON `${TABLE_NAME}` (`alarm_start_at_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_stop_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_stop_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_stop_at_ms` ON `${TABLE_NAME}` (`alarm_stop_at_ms`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "recording_schedules",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "schedule_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "program_reminders",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `channel_name` TEXT NOT NULL, `program_title` TEXT NOT NULL, `program_start_time` INTEGER NOT NULL, `remind_at` INTEGER NOT NULL, `lead_time_minutes` INTEGER NOT NULL, `is_dismissed` INTEGER NOT NULL, `notified_at` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `delivery_state` TEXT NOT NULL, `delivery_attempt_token` TEXT, `delivery_attempted_at` INTEGER, `delivery_attempt_count` INTEGER NOT NULL, `delivery_failure_reason` TEXT, `created_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programStartTime",+ "columnName": "program_start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remindAt",+ "columnName": "remind_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "leadTimeMinutes",+ "columnName": "lead_time_minutes",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isDismissed",+ "columnName": "is_dismissed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "notifiedAt",+ "columnName": "notified_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryState",+ "columnName": "delivery_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deliveryAttemptToken",+ "columnName": "delivery_attempt_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "deliveryAttemptedAt",+ "columnName": "delivery_attempted_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "deliveryAttemptCount",+ "columnName": "delivery_attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryFailureReason",+ "columnName": "delivery_failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_program_reminders_provider_id_remind_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_remind_at` ON `${TABLE_NAME}` (`provider_id`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_is_dismissed_notified_at_remind_at",+ "unique": false,+ "columnNames": [+ "is_dismissed",+ "notified_at",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_is_dismissed_notified_at_remind_at` ON `${TABLE_NAME}` (`is_dismissed`, `notified_at`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_start_time`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_title_program_start_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_title",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_title_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_title`, `program_start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_storage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `tree_uri` TEXT, `display_name` TEXT, `output_directory` TEXT, `available_bytes` INTEGER, `is_writable` INTEGER NOT NULL, `file_name_pattern` TEXT NOT NULL, `retention_days` INTEGER, `max_simultaneous_recordings` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "treeUri",+ "columnName": "tree_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDirectory",+ "columnName": "output_directory",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "availableBytes",+ "columnName": "available_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isWritable",+ "columnName": "is_writable",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "fileNamePattern",+ "columnName": "file_name_pattern",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "retentionDays",+ "columnName": "retention_days",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "maxSimultaneousRecordings",+ "columnName": "max_simultaneous_recordings",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "playback_compatibility_records",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_fingerprint` TEXT NOT NULL, `device_model` TEXT NOT NULL, `android_sdk` INTEGER NOT NULL, `stream_type` TEXT NOT NULL, `video_mime_type` TEXT NOT NULL, `resolution_bucket` TEXT NOT NULL, `decoder_name` TEXT NOT NULL, `surface_type` TEXT NOT NULL, `failure_type` TEXT NOT NULL, `last_failed_at` INTEGER NOT NULL, `last_succeeded_at` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `success_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deviceFingerprint",+ "columnName": "device_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deviceModel",+ "columnName": "device_model",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "androidSdk",+ "columnName": "android_sdk",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamType",+ "columnName": "stream_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "videoMimeType",+ "columnName": "video_mime_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolutionBucket",+ "columnName": "resolution_bucket",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "decoderName",+ "columnName": "decoder_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surfaceType",+ "columnName": "surface_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureType",+ "columnName": "failure_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastFailedAt",+ "columnName": "last_failed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSucceededAt",+ "columnName": "last_succeeded_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "successCount",+ "columnName": "success_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type",+ "unique": true,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket",+ "decoder_name",+ "surface_type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`, `decoder_name`, `surface_type`)"+ },+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket",+ "unique": false,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`)"+ },+ {+ "name": "index_playback_compatibility_records_last_failed_at",+ "unique": false,+ "columnNames": [+ "last_failed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_failed_at` ON `${TABLE_NAME}` (`last_failed_at`)"+ },+ {+ "name": "index_playback_compatibility_records_last_succeeded_at",+ "unique": false,+ "columnNames": [+ "last_succeeded_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_succeeded_at` ON `${TABLE_NAME}` (`last_succeeded_at`)"+ }+ ]+ },+ {+ "tableName": "xtream_content_index",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `remote_id` TEXT NOT NULL, `local_content_id` INTEGER, `name` TEXT NOT NULL, `category_id` INTEGER, `category_name` TEXT, `image_url` TEXT, `container_extension` TEXT, `rating` REAL NOT NULL, `added_at` INTEGER NOT NULL, `remote_updated_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `indexed_at` INTEGER NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `stale_state` TEXT NOT NULL, `error_state` TEXT, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `remote_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "remoteId",+ "columnName": "remote_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "localContentId",+ "columnName": "local_content_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteUpdatedAt",+ "columnName": "remote_updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedAt",+ "columnName": "indexed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "staleState",+ "columnName": "stale_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorState",+ "columnName": "error_state",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "remote_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_content_index_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_category_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `category_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_name",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_name` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `name`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_local_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "local_content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_local_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `local_content_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_indexed_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "indexed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_indexed_at` ON `${TABLE_NAME}` (`provider_id`, `indexed_at`)"+ },+ {+ "name": "index_xtream_content_index_stale_state",+ "unique": false,+ "columnNames": [+ "stale_state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_stale_state` ON `${TABLE_NAME}` (`stale_state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `priority_category_id` INTEGER, `priority_requested_at` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priorityCategoryId",+ "columnName": "priority_category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "priorityRequestedAt",+ "columnName": "priority_requested_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_index_jobs_section",+ "unique": false,+ "columnNames": [+ "section"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_section` ON `${TABLE_NAME}` (`section`)"+ },+ {+ "name": "index_xtream_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_xtream_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_live_onboarding_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `provider_type` TEXT NOT NULL, `content_type` TEXT NOT NULL, `phase` TEXT NOT NULL, `staged_session_id` INTEGER, `import_strategy` TEXT, `next_category_index` INTEGER NOT NULL, `accepted_row_count` INTEGER NOT NULL, `staged_flush_count` INTEGER NOT NULL, `sync_profile_tier` TEXT, `sync_profile_batch_size` INTEGER NOT NULL, `sync_profile_strategy` TEXT, `sync_profile_low_memory` INTEGER NOT NULL, `sync_profile_memory_class_mb` INTEGER NOT NULL, `sync_profile_available_mem_mb` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerType",+ "columnName": "provider_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "stagedSessionId",+ "columnName": "staged_session_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "importStrategy",+ "columnName": "import_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "acceptedRowCount",+ "columnName": "accepted_row_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stagedFlushCount",+ "columnName": "staged_flush_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileTier",+ "columnName": "sync_profile_tier",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileBatchSize",+ "columnName": "sync_profile_batch_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileStrategy",+ "columnName": "sync_profile_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileLowMemory",+ "columnName": "sync_profile_low_memory",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileMemoryClassMb",+ "columnName": "sync_profile_memory_class_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileAvailableMemMb",+ "columnName": "sync_profile_available_mem_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_live_onboarding_state_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_phase",+ "unique": false,+ "columnNames": [+ "phase"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_phase` ON `${TABLE_NAME}` (`phase`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_staged_session_id",+ "unique": false,+ "columnNames": [+ "staged_session_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_staged_session_id` ON `${TABLE_NAME}` (`staged_session_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_stalker_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_portal_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `working_endpoint` TEXT, `bootstrap_recipe` TEXT, `bulk_live_supported` INTEGER, `bulk_live_category_fidelity` INTEGER, `movie_wildcard_supported` INTEGER, `series_wildcard_supported` INTEGER, `epg_supported` INTEGER, `safe_metadata_concurrency` INTEGER NOT NULL, `stress_cooldown_until` INTEGER NOT NULL, `endpoint_health_json` TEXT NOT NULL, `endpoint_failed_until` INTEGER NOT NULL, `validated_at` INTEGER NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `learning_json` TEXT NOT NULL, `observation_source` TEXT NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "workingEndpoint",+ "columnName": "working_endpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bootstrapRecipe",+ "columnName": "bootstrap_recipe",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bulkLiveSupported",+ "columnName": "bulk_live_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "bulkLiveCategoryFidelity",+ "columnName": "bulk_live_category_fidelity",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "movieWildcardSupported",+ "columnName": "movie_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesWildcardSupported",+ "columnName": "series_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "epgSupported",+ "columnName": "epg_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "safeMetadataConcurrency",+ "columnName": "safe_metadata_concurrency",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stressCooldownUntil",+ "columnName": "stress_cooldown_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endpointHealthJson",+ "columnName": "endpoint_health_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "endpointFailedUntil",+ "columnName": "endpoint_failed_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "validatedAt",+ "columnName": "validated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "learningJson",+ "columnName": "learning_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observationSource",+ "columnName": "observation_source",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_portal_state_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_portal_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_remote_identities",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `raw_id` TEXT NOT NULL, `surrogate_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `raw_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rawId",+ "columnName": "raw_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surrogateId",+ "columnName": "surrogate_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "raw_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_remote_identities_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_remote_identities_provider_id_content_type_surrogate_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_type",+ "surrogate_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id_content_type_surrogate_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `surrogate_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_discovery_staging",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`discovery_id` TEXT NOT NULL, `provider_id` INTEGER, `configuration_generation` INTEGER NOT NULL, `sanitized_summary` TEXT NOT NULL, `categories_json` TEXT NOT NULL, `channels_json` TEXT NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`discovery_id`))",+ "fields": [+ {+ "fieldPath": "discoveryId",+ "columnName": "discovery_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sanitizedSummary",+ "columnName": "sanitized_summary",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoriesJson",+ "columnName": "categories_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelsJson",+ "columnName": "channels_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "discovery_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_discovery_staging_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_discovery_staging_created_at",+ "unique": false,+ "columnNames": [+ "created_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_created_at` ON `${TABLE_NAME}` (`created_at`)"+ }+ ]+ },+ {+ "tableName": "downloads",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `content_id` INTEGER NOT NULL, `content_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `source_stream_url` TEXT, `source_stream_id` INTEGER, `container_extension` TEXT, `poster_url` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `status` TEXT NOT NULL, `bytes_written` INTEGER NOT NULL, `total_bytes` INTEGER, `supports_resume` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `completed_at` INTEGER, `failure_reason` TEXT, `owner_id` TEXT, `owner_epoch` INTEGER NOT NULL, `heartbeat_at` INTEGER, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentName",+ "columnName": "content_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceStreamUrl",+ "columnName": "source_stream_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "sourceStreamId",+ "columnName": "source_stream_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalBytes",+ "columnName": "total_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "supportsResume",+ "columnName": "supports_resume",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerId",+ "columnName": "owner_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerEpoch",+ "columnName": "owner_epoch",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_downloads_status",+ "unique": false,+ "columnNames": [+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_status` ON `${TABLE_NAME}` (`status`)"+ },+ {+ "name": "index_downloads_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_downloads_content_type_content_id",+ "unique": false,+ "columnNames": [+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_content_type_content_id` ON `${TABLE_NAME}` (`content_type`, `content_id`)"+ }+ ]+ },+ {+ "tableName": "provider_deletion_cleanup",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `action` TEXT NOT NULL, `target_id` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "action",+ "columnName": "action",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_deletion_cleanup_provider_id_action_target_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "action",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_deletion_cleanup_provider_id_action_target_id` ON `${TABLE_NAME}` (`provider_id`, `action`, `target_id`)"+ }+ ]+ },+ {+ "tableName": "plugin_provider_ownership",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `service_class_name` TEXT NOT NULL, `manifest_id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`package_name`, `service_class_name`, `manifest_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "packageName",+ "columnName": "package_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "serviceClassName",+ "columnName": "service_class_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "manifestId",+ "columnName": "manifest_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "package_name",+ "service_class_name",+ "manifest_id"+ ]+ },+ "indices": [+ {+ "name": "index_plugin_provider_ownership_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_plugin_provider_ownership_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_config_revisions",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `revision` INTEGER NOT NULL, `config_json` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `revision`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "revision",+ "columnName": "revision",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configJson",+ "columnName": "config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "revision"+ ]+ },+ "indices": [+ {+ "name": "index_provider_config_revisions_provider_id_state",+ "unique": false,+ "columnNames": [+ "provider_id",+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_config_revisions_provider_id_state` ON `${TABLE_NAME}` (`provider_id`, `state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "backup_restore_checkpoints",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`restore_key` TEXT NOT NULL, `room_complete` INTEGER NOT NULL, `preferences_complete` INTEGER NOT NULL, `presets_complete` INTEGER NOT NULL, `schedules_complete` INTEGER NOT NULL, `state` TEXT NOT NULL, `preference_snapshot_json` TEXT, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`restore_key`))",+ "fields": [+ {+ "fieldPath": "restoreKey",+ "columnName": "restore_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "roomComplete",+ "columnName": "room_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "preferencesComplete",+ "columnName": "preferences_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "presetsComplete",+ "columnName": "presets_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schedulesComplete",+ "columnName": "schedules_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "preferenceSnapshotJson",+ "columnName": "preference_snapshot_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "restore_key"+ ]+ }+ },+ {+ "tableName": "backup_restore_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `restore_key` TEXT NOT NULL, `backup_version` INTEGER NOT NULL, `conflict_strategy` TEXT NOT NULL, `status` TEXT NOT NULL, `total_count` INTEGER NOT NULL, `pending_count` INTEGER NOT NULL, `applied_count` INTEGER NOT NULL, `unresolved_count` INTEGER NOT NULL, `failed_count` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "restoreKey",+ "columnName": "restore_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "backupVersion",+ "columnName": "backup_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "conflictStrategy",+ "columnName": "conflict_strategy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCount",+ "columnName": "total_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pendingCount",+ "columnName": "pending_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "appliedCount",+ "columnName": "applied_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "unresolvedCount",+ "columnName": "unresolved_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCount",+ "columnName": "failed_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_backup_restore_jobs_restore_key",+ "unique": true,+ "columnNames": [+ "restore_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_backup_restore_jobs_restore_key` ON `${TABLE_NAME}` (`restore_key`)"+ },+ {+ "name": "index_backup_restore_jobs_status",+ "unique": false,+ "columnNames": [+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_jobs_status` ON `${TABLE_NAME}` (`status`)"+ },+ {+ "name": "index_backup_restore_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ]+ },+ {+ "tableName": "backup_restore_items",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `job_id` TEXT NOT NULL, `provider_identity_key` TEXT NOT NULL, `local_provider_id` INTEGER, `section` TEXT NOT NULL, `content_type` TEXT, `stable_reference_key` TEXT NOT NULL, `reference_json` TEXT NOT NULL, `payload_json` TEXT NOT NULL, `status` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`job_id`) REFERENCES `backup_restore_jobs`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "jobId",+ "columnName": "job_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerIdentityKey",+ "columnName": "provider_identity_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "localProviderId",+ "columnName": "local_provider_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "stableReferenceKey",+ "columnName": "stable_reference_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "referenceJson",+ "columnName": "reference_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "payloadJson",+ "columnName": "payload_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_backup_restore_items_job_id",+ "unique": false,+ "columnNames": [+ "job_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_job_id` ON `${TABLE_NAME}` (`job_id`)"+ },+ {+ "name": "index_backup_restore_items_provider_identity_key_status",+ "unique": false,+ "columnNames": [+ "provider_identity_key",+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_provider_identity_key_status` ON `${TABLE_NAME}` (`provider_identity_key`, `status`)"+ },+ {+ "name": "index_backup_restore_items_job_id_status",+ "unique": false,+ "columnNames": [+ "job_id",+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_job_id_status` ON `${TABLE_NAME}` (`job_id`, `status`)"+ },+ {+ "name": "index_backup_restore_items_job_id_section_stable_reference_key",+ "unique": true,+ "columnNames": [+ "job_id",+ "section",+ "stable_reference_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_backup_restore_items_job_id_section_stable_reference_key` ON `${TABLE_NAME}` (`job_id`, `section`, `stable_reference_key`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "backup_restore_jobs",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "job_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_workflows",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `state` TEXT NOT NULL, `reason` TEXT NOT NULL, `priority` INTEGER NOT NULL, `force` INTEGER NOT NULL, `current_phase` TEXT, `lease_token` TEXT, `lease_expires_at` INTEGER, `heartbeat_at` INTEGER, `progress_message` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "reason",+ "columnName": "reason",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "force",+ "columnName": "force",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "currentPhase",+ "columnName": "current_phase",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseToken",+ "columnName": "lease_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseExpiresAt",+ "columnName": "lease_expires_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "progressMessage",+ "columnName": "progress_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflows_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflows_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_provider_workflows_lease_expires_at",+ "unique": false,+ "columnNames": [+ "lease_expires_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_lease_expires_at` ON `${TABLE_NAME}` (`lease_expires_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_workflow_phases",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `phase` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `checkpoint` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`, `generation`, `phase`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "checkpoint",+ "columnName": "checkpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "generation",+ "phase"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflow_phases_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_workflow_phases_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflow_phases_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_classification_overrides",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `source_key` TEXT NOT NULL, `stream_id` INTEGER NOT NULL, `target_type` TEXT NOT NULL, `group_key` TEXT NOT NULL, `series_key` TEXT, `series_name` TEXT, `season_number` INTEGER, `episode_number` INTEGER, `episode_title` TEXT, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `source_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceKey",+ "columnName": "source_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesKey",+ "columnName": "series_key",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesName",+ "columnName": "series_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeTitle",+ "columnName": "episode_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "source_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_classification_overrides_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_classification_overrides_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_category_classification_rules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `group_key` TEXT NOT NULL, `target_type` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `group_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "group_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_category_classification_rules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_category_classification_rules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ }+ ],+ "setupQueries": [+ "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",+ "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '5074bfd566d603d838fdd377c95cf973')"+ ]+ }+}\ No newline at end of filediff --git a/data/schemas/com.streamvault.data.local.StreamVaultDatabase/80.json b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/80.jsonnew file mode 100644index 00000000..3f07a10c--- /dev/null+++ b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/80.json@@ -0,0 +1,7122 @@+{+ "formatVersion": 1,+ "database": {+ "version": 80,+ "identityHash": "bf6f92b8689ef564643e5c397acc582f",+ "entities": [+ {+ "tableName": "providers",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `type` TEXT NOT NULL, `is_active` INTEGER NOT NULL, `status` TEXT NOT NULL, `last_synced_at` INTEGER NOT NULL, `created_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "isActive",+ "columnName": "is_active",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncedAt",+ "columnName": "last_synced_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_providers_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_type` ON `${TABLE_NAME}` (`type`)"+ },+ {+ "name": "index_providers_is_active",+ "unique": false,+ "columnNames": [+ "is_active"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_is_active` ON `${TABLE_NAME}` (`is_active`)"+ }+ ]+ },+ {+ "tableName": "provider_configs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `type` TEXT NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `identity_key` TEXT NOT NULL, `encrypted_config_json` TEXT NOT NULL, `guide_source_policy` TEXT NOT NULL, `channel_logo_source_policy` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "identityKey",+ "columnName": "identity_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "encryptedConfigJson",+ "columnName": "encrypted_config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "guideSourcePolicy",+ "columnName": "guide_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelLogoSourcePolicy",+ "columnName": "channel_logo_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_configs_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_configs_identity_key",+ "unique": true,+ "columnNames": [+ "identity_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_identity_key` ON `${TABLE_NAME}` (`identity_key`)"+ },+ {+ "name": "index_provider_configs_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_configs_type` ON `${TABLE_NAME}` (`type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_account_runtime",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `max_connections` INTEGER NOT NULL, `expiration_date` INTEGER, `api_version` TEXT, `allowed_output_formats_json` TEXT NOT NULL, `catalog_layout` TEXT NOT NULL, `catalog_layout_detection_version` INTEGER NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "maxConnections",+ "columnName": "max_connections",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "expirationDate",+ "columnName": "expiration_date",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "apiVersion",+ "columnName": "api_version",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "allowedOutputFormatsJson",+ "columnName": "allowed_output_formats_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayout",+ "columnName": "catalog_layout",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayoutDetectionVersion",+ "columnName": "catalog_layout_detection_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_account_runtime_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_account_runtime_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `quality_options_json` TEXT, `playback_metadata_json` TEXT, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "qualityOptionsJson",+ "columnName": "quality_options_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channels_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_channels_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channels_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_channels_logical_group_id",+ "unique": false,+ "columnNames": [+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_logical_group_id` ON `${TABLE_NAME}` (`logical_group_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id_logical_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id_logical_group_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `logical_group_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_preferences",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `channel_id` INTEGER NOT NULL, `aspect_ratio` TEXT, `audio_video_offset_ms` INTEGER, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`channel_id`) REFERENCES `channels`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "aspectRatio",+ "columnName": "aspect_ratio",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "audioVideoOffsetMs",+ "columnName": "audio_video_offset_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_preferences_channel_id",+ "unique": true,+ "columnNames": [+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_preferences_channel_id` ON `${TABLE_NAME}` (`channel_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "channels",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "channel_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`channels`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "channels",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_UPDATE BEFORE UPDATE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_DELETE BEFORE DELETE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_UPDATE AFTER UPDATE ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_INSERT AFTER INSERT ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "movies",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `added_at` INTEGER NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, `playback_metadata_json` TEXT, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_movies_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movies_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_movies_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_movies_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_movies_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_added_at_release_date_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "added_at",+ "release_date",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_added_at_release_date_name_id` ON `${TABLE_NAME}` (`provider_id`, `added_at`, `release_date`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movies_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`movies`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "movies",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_UPDATE BEFORE UPDATE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_DELETE BEFORE DELETE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_UPDATE AFTER UPDATE ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_INSERT AFTER INSERT ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "series",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, `catalog_origin` TEXT NOT NULL, `episode_playback_template_url` TEXT, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catalogOrigin",+ "columnName": "catalog_origin",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodePlaybackTemplateUrl",+ "columnName": "episode_playback_template_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_series_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_series_provider_id_series_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_series_provider_id_series_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`)"+ },+ {+ "name": "index_series_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_last_modified_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "last_modified",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_last_modified_name_id` ON `${TABLE_NAME}` (`provider_id`, `last_modified`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`series`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "series",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_UPDATE BEFORE UPDATE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_DELETE BEFORE DELETE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_UPDATE AFTER UPDATE ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_INSERT AFTER INSERT ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "episodes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `episode_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `episode_number` INTEGER NOT NULL, `season_number` INTEGER NOT NULL, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `cover_url` TEXT, `plot` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `release_date` TEXT, `series_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`series_id`) REFERENCES `series`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "episodeId",+ "columnName": "episode_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "coverUrl",+ "columnName": "cover_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_episodes_series_id",+ "unique": false,+ "columnNames": [+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_series_id` ON `${TABLE_NAME}` (`series_id`)"+ },+ {+ "name": "index_episodes_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_episodes_provider_id_series_id_episode_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "series_id",+ "episode_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_episodes_provider_id_series_id_episode_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`, `episode_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "series",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "series_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "categories",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_categories_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_categories_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ },+ {+ "name": "index_categories_provider_id_category_id_type",+ "unique": true,+ "columnNames": [+ "provider_id",+ "category_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_categories_provider_id_category_id_type` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `is_adult` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `playback_metadata_json` TEXT, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channel_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `playback_metadata_json` TEXT, `added_at` INTEGER NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movie_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `provider_series_key` TEXT NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `provider_series_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerSeriesKey",+ "columnName": "provider_series_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "provider_series_key"+ ]+ },+ "indices": [+ {+ "name": "index_series_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "category_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `category_id`, `type`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "category_id",+ "type"+ ]+ },+ "indices": [+ {+ "name": "index_category_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_category_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ },+ {+ "name": "index_category_import_stage_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "programs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `title` TEXT NOT NULL, `description` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `genre` TEXT, `category` TEXT, `has_archive` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "hasArchive",+ "columnName": "has_archive",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_programs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_programs_provider_id_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id` ON `${TABLE_NAME}` (`provider_id`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_end_time_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "end_time",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_end_time_channel_id` ON `${TABLE_NAME}` (`provider_id`, `end_time`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_start_time_end_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_programs_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_start_time` ON `${TABLE_NAME}` (`start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`, `end_time`)"+ }+ ]+ },+ {+ "tableName": "favorites",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `position` INTEGER NOT NULL, `group_id` INTEGER, `group_key` INTEGER NOT NULL, `added_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`group_id`) REFERENCES `virtual_groups`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupId",+ "columnName": "group_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_favorites_provider_id_content_id_content_type_group_key",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_id",+ "content_type",+ "group_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_favorites_provider_id_content_id_content_type_group_key` ON `${TABLE_NAME}` (`provider_id`, `content_id`, `content_type`, `group_key`)"+ },+ {+ "name": "index_favorites_provider_id_content_type_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_provider_id_content_type_group_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `group_id`)"+ },+ {+ "name": "index_favorites_group_id_position",+ "unique": false,+ "columnNames": [+ "group_id",+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_group_id_position` ON `${TABLE_NAME}` (`group_id`, `position`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "virtual_groups",+ "onDelete": "SET NULL",+ "onUpdate": "NO ACTION",+ "columns": [+ "group_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "virtual_groups",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `icon_emoji` TEXT, `position` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `content_type` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconEmoji",+ "columnName": "icon_emoji",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_virtual_groups_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_virtual_groups_position",+ "unique": false,+ "columnNames": [+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_position` ON `${TABLE_NAME}` (`position`)"+ },+ {+ "name": "index_virtual_groups_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_content_type` ON `${TABLE_NAME}` (`content_type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "playback_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `poster_url` TEXT, `stream_url` TEXT NOT NULL, `resume_position_ms` INTEGER NOT NULL, `total_duration_ms` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `watched_status` TEXT NOT NULL, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resumePositionMs",+ "columnName": "resume_position_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalDurationMs",+ "columnName": "total_duration_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchedStatus",+ "columnName": "watched_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_history_content_id_content_type_provider_id",+ "unique": true,+ "columnNames": [+ "content_id",+ "content_type",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_history_content_id_content_type_provider_id` ON `${TABLE_NAME}` (`content_id`, `content_type`, `provider_id`)"+ },+ {+ "name": "index_playback_history_last_watched_at",+ "unique": false,+ "columnNames": [+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_last_watched_at` ON `${TABLE_NAME}` (`last_watched_at`)"+ },+ {+ "name": "index_playback_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `content_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_last_watched_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_last_watched_at` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `last_watched_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "tmdb_identity",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tmdb_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `canonical_provider_id` INTEGER NOT NULL, `first_seen_at` INTEGER NOT NULL, PRIMARY KEY(`tmdb_id`, `content_type`), FOREIGN KEY(`canonical_provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "canonicalProviderId",+ "columnName": "canonical_provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "firstSeenAt",+ "columnName": "first_seen_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "tmdb_id",+ "content_type"+ ]+ },+ "indices": [+ {+ "name": "index_tmdb_identity_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_content_type` ON `${TABLE_NAME}` (`content_type`)"+ },+ {+ "name": "index_tmdb_identity_canonical_provider_id",+ "unique": false,+ "columnNames": [+ "canonical_provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_canonical_provider_id` ON `${TABLE_NAME}` (`canonical_provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "canonical_provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "search_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `query` TEXT NOT NULL, `content_scope` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `used_at` INTEGER NOT NULL, `use_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "query",+ "columnName": "query",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentScope",+ "columnName": "content_scope",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "usedAt",+ "columnName": "used_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "useCount",+ "columnName": "use_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_search_history_content_scope_provider_id_used_at",+ "unique": false,+ "columnNames": [+ "content_scope",+ "provider_id",+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_content_scope_provider_id_used_at` ON `${TABLE_NAME}` (`content_scope`, `provider_id`, `used_at`)"+ },+ {+ "name": "index_search_history_used_at",+ "unique": false,+ "columnNames": [+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_used_at` ON `${TABLE_NAME}` (`used_at`)"+ },+ {+ "name": "index_search_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_search_history_query_content_scope_provider_id",+ "unique": true,+ "columnNames": [+ "query",+ "content_scope",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_search_history_query_content_scope_provider_id` ON `${TABLE_NAME}` (`query`, `content_scope`, `provider_id`)"+ }+ ]+ },+ {+ "tableName": "sync_metadata",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `last_live_sync` INTEGER NOT NULL, `last_live_success` INTEGER NOT NULL, `last_movie_sync` INTEGER NOT NULL, `last_series_sync` INTEGER NOT NULL, `last_series_success` INTEGER NOT NULL, `last_epg_sync` INTEGER NOT NULL, `last_epg_success` INTEGER NOT NULL, `last_movie_attempt` INTEGER NOT NULL, `last_movie_success` INTEGER NOT NULL, `last_movie_partial` INTEGER NOT NULL, `live_count` INTEGER NOT NULL, `movie_count` INTEGER NOT NULL, `series_count` INTEGER NOT NULL, `epg_count` INTEGER NOT NULL, `last_sync_status` TEXT NOT NULL, `movie_sync_mode` TEXT NOT NULL, `movie_warnings_count` INTEGER NOT NULL, `movie_catalog_stale` INTEGER NOT NULL, `live_avoid_full_until` INTEGER NOT NULL, `movie_avoid_full_until` INTEGER NOT NULL, `series_avoid_full_until` INTEGER NOT NULL, `live_sequential_failures_remembered` INTEGER NOT NULL, `live_healthy_sync_streak` INTEGER NOT NULL, `movie_parallel_failures_remembered` INTEGER NOT NULL, `movie_healthy_sync_streak` INTEGER NOT NULL, `series_sequential_failures_remembered` INTEGER NOT NULL, `series_healthy_sync_streak` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSync",+ "columnName": "last_live_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSuccess",+ "columnName": "last_live_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSync",+ "columnName": "last_movie_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSync",+ "columnName": "last_series_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSuccess",+ "columnName": "last_series_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSync",+ "columnName": "last_epg_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSuccess",+ "columnName": "last_epg_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieAttempt",+ "columnName": "last_movie_attempt",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSuccess",+ "columnName": "last_movie_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMoviePartial",+ "columnName": "last_movie_partial",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveCount",+ "columnName": "live_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCount",+ "columnName": "movie_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesCount",+ "columnName": "series_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgCount",+ "columnName": "epg_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncStatus",+ "columnName": "last_sync_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieSyncMode",+ "columnName": "movie_sync_mode",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieWarningsCount",+ "columnName": "movie_warnings_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCatalogStale",+ "columnName": "movie_catalog_stale",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveAvoidFullUntil",+ "columnName": "live_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieAvoidFullUntil",+ "columnName": "movie_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesAvoidFullUntil",+ "columnName": "series_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveSequentialFailuresRemembered",+ "columnName": "live_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveHealthySyncStreak",+ "columnName": "live_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieParallelFailuresRemembered",+ "columnName": "movie_parallel_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieHealthySyncStreak",+ "columnName": "movie_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesSequentialFailuresRemembered",+ "columnName": "series_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesHealthySyncStreak",+ "columnName": "series_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_series_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `page_size` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `is_complete` INTEGER NOT NULL, `has_movies` INTEGER NOT NULL, `has_series` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasMovies",+ "columnName": "has_movies",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasSeries",+ "columnName": "has_series",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_catalog_entries",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `raw_item_id` TEXT NOT NULL, `item_type` TEXT NOT NULL, `target_id` INTEGER NOT NULL, `raw_page` INTEGER NOT NULL, `raw_index` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `category_id`, `raw_item_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawItemId",+ "columnName": "raw_item_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "itemType",+ "columnName": "item_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawPage",+ "columnName": "raw_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawIndex",+ "columnName": "raw_index",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_item_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_catalog_entries_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_page",+ "raw_index"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `raw_page`, `raw_index`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_item_type_target_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "item_type",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_item_type_target_id` ON `${TABLE_NAME}` (`provider_id`, `item_type`, `target_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `url` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `last_refresh_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `last_error` TEXT, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `etag` TEXT, `last_modified_header` TEXT, `timezone_policy` TEXT NOT NULL, `timezone_id` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "url",+ "columnName": "url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastRefreshAt",+ "columnName": "last_refresh_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "etag",+ "columnName": "etag",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModifiedHeader",+ "columnName": "last_modified_header",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "timezonePolicy",+ "columnName": "timezone_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "timezoneId",+ "columnName": "timezone_id",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_sources_url",+ "unique": true,+ "columnNames": [+ "url"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_sources_url` ON `${TABLE_NAME}` (`url`)"+ }+ ]+ },+ {+ "tableName": "provider_epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `epg_source_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_epg_sources_provider_id_epg_source_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_epg_sources_provider_id_epg_source_id` ON `${TABLE_NAME}` (`provider_id`, `epg_source_id`)"+ },+ {+ "name": "index_provider_epg_sources_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_epg_sources_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `display_name` TEXT NOT NULL, `normalized_name` TEXT NOT NULL, `icon_url` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "normalizedName",+ "columnName": "normalized_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconUrl",+ "columnName": "icon_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_channels_epg_source_id_xmltv_channel_id",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id_xmltv_channel_id` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`)"+ },+ {+ "name": "index_epg_channels_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_channels_normalized_name",+ "unique": false,+ "columnNames": [+ "normalized_name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_normalized_name` ON `${TABLE_NAME}` (`normalized_name`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_programmes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `title` TEXT NOT NULL, `subtitle` TEXT, `description` TEXT NOT NULL, `category` TEXT, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `episode_info` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "subtitle",+ "columnName": "subtitle",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeInfo",+ "columnName": "episode_info",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_programmes_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_start_time` ON `${TABLE_NAME}` (`start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_epg_mappings",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_channel_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `source_type` TEXT NOT NULL, `epg_source_id` INTEGER, `xmltv_channel_id` TEXT, `match_type` TEXT, `confidence` REAL NOT NULL, `matched_at` INTEGER NOT NULL, `failed_attempts` INTEGER NOT NULL, `source` TEXT, `is_manual_override` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerChannelId",+ "columnName": "provider_channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "matchType",+ "columnName": "match_type",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "confidence",+ "columnName": "confidence",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "matchedAt",+ "columnName": "matched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedAttempts",+ "columnName": "failed_attempts",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "source",+ "columnName": "source",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isManualOverride",+ "columnName": "is_manual_override",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_epg_mappings_provider_id_provider_channel_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "provider_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id_provider_channel_id` ON `${TABLE_NAME}` (`provider_id`, `provider_channel_id`)"+ },+ {+ "name": "index_channel_epg_mappings_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "combined_m3u_profiles",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "combined_m3u_profile_members",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `profile_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`profile_id`) REFERENCES `combined_m3u_profiles`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "profileId",+ "columnName": "profile_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_combined_m3u_profile_members_profile_id",+ "unique": false,+ "columnNames": [+ "profile_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id` ON `${TABLE_NAME}` (`profile_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_profile_id_provider_id",+ "unique": true,+ "columnNames": [+ "profile_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id_provider_id` ON `${TABLE_NAME}` (`profile_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "combined_m3u_profiles",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "profile_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_schedules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `requested_start_ms` INTEGER NOT NULL, `requested_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `enabled` INTEGER NOT NULL, `is_manual` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "requestedStartMs",+ "columnName": "requested_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "requestedEndMs",+ "columnName": "requested_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isManual",+ "columnName": "is_manual",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_schedules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_schedules_enabled_requested_start_ms",+ "unique": false,+ "columnNames": [+ "enabled",+ "requested_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_enabled_requested_start_ms` ON `${TABLE_NAME}` (`enabled`, `requested_start_ms`)"+ },+ {+ "name": "index_recording_schedules_recurring_rule_id",+ "unique": false,+ "columnNames": [+ "recurring_rule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_recurring_rule_id` ON `${TABLE_NAME}` (`recurring_rule_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_runs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `schedule_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `scheduled_start_ms` INTEGER NOT NULL, `scheduled_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `status` TEXT NOT NULL, `source_type` TEXT NOT NULL, `resolved_url` TEXT, `headers_json` TEXT NOT NULL, `user_agent` TEXT, `expiration_time` INTEGER, `provider_label` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `bytes_written` INTEGER NOT NULL, `average_throughput_bps` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `last_progress_at_ms` INTEGER, `failure_category` TEXT NOT NULL, `failure_reason` TEXT, `terminal_at_ms` INTEGER, `started_at_ms` INTEGER, `ended_at_ms` INTEGER, `schedule_enabled` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `alarm_start_at_ms` INTEGER, `alarm_stop_at_ms` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`schedule_id`) REFERENCES `recording_schedules`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "scheduleId",+ "columnName": "schedule_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "scheduledStartMs",+ "columnName": "scheduled_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "scheduledEndMs",+ "columnName": "scheduled_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolvedUrl",+ "columnName": "resolved_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "headersJson",+ "columnName": "headers_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "userAgent",+ "columnName": "user_agent",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "expirationTime",+ "columnName": "expiration_time",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "providerLabel",+ "columnName": "provider_label",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "averageThroughputBytesPerSecond",+ "columnName": "average_throughput_bps",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastProgressAtMs",+ "columnName": "last_progress_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureCategory",+ "columnName": "failure_category",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "terminalAtMs",+ "columnName": "terminal_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "startedAtMs",+ "columnName": "started_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "endedAtMs",+ "columnName": "ended_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "scheduleEnabled",+ "columnName": "schedule_enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "alarmStartAtMs",+ "columnName": "alarm_start_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "alarmStopAtMs",+ "columnName": "alarm_stop_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_runs_schedule_id",+ "unique": false,+ "columnNames": [+ "schedule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_schedule_id` ON `${TABLE_NAME}` (`schedule_id`)"+ },+ {+ "name": "index_recording_runs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_runs_status_scheduled_start_ms",+ "unique": false,+ "columnNames": [+ "status",+ "scheduled_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_status_scheduled_start_ms` ON `${TABLE_NAME}` (`status`, `scheduled_start_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_start_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_start_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_start_at_ms` ON `${TABLE_NAME}` (`alarm_start_at_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_stop_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_stop_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_stop_at_ms` ON `${TABLE_NAME}` (`alarm_stop_at_ms`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "recording_schedules",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "schedule_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "program_reminders",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `channel_name` TEXT NOT NULL, `program_title` TEXT NOT NULL, `program_start_time` INTEGER NOT NULL, `remind_at` INTEGER NOT NULL, `lead_time_minutes` INTEGER NOT NULL, `is_dismissed` INTEGER NOT NULL, `notified_at` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `delivery_state` TEXT NOT NULL, `delivery_attempt_token` TEXT, `delivery_attempted_at` INTEGER, `delivery_attempt_count` INTEGER NOT NULL, `delivery_failure_reason` TEXT, `created_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programStartTime",+ "columnName": "program_start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remindAt",+ "columnName": "remind_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "leadTimeMinutes",+ "columnName": "lead_time_minutes",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isDismissed",+ "columnName": "is_dismissed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "notifiedAt",+ "columnName": "notified_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryState",+ "columnName": "delivery_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deliveryAttemptToken",+ "columnName": "delivery_attempt_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "deliveryAttemptedAt",+ "columnName": "delivery_attempted_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "deliveryAttemptCount",+ "columnName": "delivery_attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryFailureReason",+ "columnName": "delivery_failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_program_reminders_provider_id_remind_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_remind_at` ON `${TABLE_NAME}` (`provider_id`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_is_dismissed_notified_at_remind_at",+ "unique": false,+ "columnNames": [+ "is_dismissed",+ "notified_at",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_is_dismissed_notified_at_remind_at` ON `${TABLE_NAME}` (`is_dismissed`, `notified_at`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_start_time`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_title_program_start_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_title",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_title_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_title`, `program_start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_storage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `tree_uri` TEXT, `display_name` TEXT, `output_directory` TEXT, `available_bytes` INTEGER, `is_writable` INTEGER NOT NULL, `file_name_pattern` TEXT NOT NULL, `retention_days` INTEGER, `max_simultaneous_recordings` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "treeUri",+ "columnName": "tree_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDirectory",+ "columnName": "output_directory",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "availableBytes",+ "columnName": "available_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isWritable",+ "columnName": "is_writable",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "fileNamePattern",+ "columnName": "file_name_pattern",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "retentionDays",+ "columnName": "retention_days",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "maxSimultaneousRecordings",+ "columnName": "max_simultaneous_recordings",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "playback_compatibility_records",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_fingerprint` TEXT NOT NULL, `device_model` TEXT NOT NULL, `android_sdk` INTEGER NOT NULL, `stream_type` TEXT NOT NULL, `video_mime_type` TEXT NOT NULL, `resolution_bucket` TEXT NOT NULL, `decoder_name` TEXT NOT NULL, `surface_type` TEXT NOT NULL, `failure_type` TEXT NOT NULL, `last_failed_at` INTEGER NOT NULL, `last_succeeded_at` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `success_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deviceFingerprint",+ "columnName": "device_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deviceModel",+ "columnName": "device_model",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "androidSdk",+ "columnName": "android_sdk",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamType",+ "columnName": "stream_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "videoMimeType",+ "columnName": "video_mime_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolutionBucket",+ "columnName": "resolution_bucket",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "decoderName",+ "columnName": "decoder_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surfaceType",+ "columnName": "surface_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureType",+ "columnName": "failure_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastFailedAt",+ "columnName": "last_failed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSucceededAt",+ "columnName": "last_succeeded_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "successCount",+ "columnName": "success_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type",+ "unique": true,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket",+ "decoder_name",+ "surface_type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`, `decoder_name`, `surface_type`)"+ },+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket",+ "unique": false,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`)"+ },+ {+ "name": "index_playback_compatibility_records_last_failed_at",+ "unique": false,+ "columnNames": [+ "last_failed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_failed_at` ON `${TABLE_NAME}` (`last_failed_at`)"+ },+ {+ "name": "index_playback_compatibility_records_last_succeeded_at",+ "unique": false,+ "columnNames": [+ "last_succeeded_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_succeeded_at` ON `${TABLE_NAME}` (`last_succeeded_at`)"+ }+ ]+ },+ {+ "tableName": "xtream_content_index",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `remote_id` TEXT NOT NULL, `local_content_id` INTEGER, `name` TEXT NOT NULL, `category_id` INTEGER, `category_name` TEXT, `image_url` TEXT, `container_extension` TEXT, `rating` REAL NOT NULL, `added_at` INTEGER NOT NULL, `remote_updated_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `indexed_at` INTEGER NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `stale_state` TEXT NOT NULL, `error_state` TEXT, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `remote_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "remoteId",+ "columnName": "remote_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "localContentId",+ "columnName": "local_content_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteUpdatedAt",+ "columnName": "remote_updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedAt",+ "columnName": "indexed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "staleState",+ "columnName": "stale_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorState",+ "columnName": "error_state",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "remote_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_content_index_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_category_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `category_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_name",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_name` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `name`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_local_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "local_content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_local_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `local_content_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_indexed_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "indexed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_indexed_at` ON `${TABLE_NAME}` (`provider_id`, `indexed_at`)"+ },+ {+ "name": "index_xtream_content_index_stale_state",+ "unique": false,+ "columnNames": [+ "stale_state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_stale_state` ON `${TABLE_NAME}` (`stale_state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `priority_category_id` INTEGER, `priority_requested_at` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priorityCategoryId",+ "columnName": "priority_category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "priorityRequestedAt",+ "columnName": "priority_requested_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_index_jobs_section",+ "unique": false,+ "columnNames": [+ "section"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_section` ON `${TABLE_NAME}` (`section`)"+ },+ {+ "name": "index_xtream_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_xtream_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_live_onboarding_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `provider_type` TEXT NOT NULL, `content_type` TEXT NOT NULL, `phase` TEXT NOT NULL, `staged_session_id` INTEGER, `import_strategy` TEXT, `next_category_index` INTEGER NOT NULL, `accepted_row_count` INTEGER NOT NULL, `staged_flush_count` INTEGER NOT NULL, `sealed_session_id` INTEGER, `sealed_row_count` INTEGER NOT NULL DEFAULT 0, `sealed_configuration_generation` INTEGER, `sealed_mapping_profile` TEXT, `sync_profile_tier` TEXT, `sync_profile_batch_size` INTEGER NOT NULL, `sync_profile_strategy` TEXT, `sync_profile_low_memory` INTEGER NOT NULL, `sync_profile_memory_class_mb` INTEGER NOT NULL, `sync_profile_available_mem_mb` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerType",+ "columnName": "provider_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "stagedSessionId",+ "columnName": "staged_session_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "importStrategy",+ "columnName": "import_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "acceptedRowCount",+ "columnName": "accepted_row_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stagedFlushCount",+ "columnName": "staged_flush_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sealedSessionId",+ "columnName": "sealed_session_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "sealedRowCount",+ "columnName": "sealed_row_count",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "sealedConfigurationGeneration",+ "columnName": "sealed_configuration_generation",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "sealedMappingProfile",+ "columnName": "sealed_mapping_profile",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileTier",+ "columnName": "sync_profile_tier",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileBatchSize",+ "columnName": "sync_profile_batch_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileStrategy",+ "columnName": "sync_profile_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileLowMemory",+ "columnName": "sync_profile_low_memory",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileMemoryClassMb",+ "columnName": "sync_profile_memory_class_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileAvailableMemMb",+ "columnName": "sync_profile_available_mem_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_live_onboarding_state_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_phase",+ "unique": false,+ "columnNames": [+ "phase"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_phase` ON `${TABLE_NAME}` (`phase`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_staged_session_id",+ "unique": false,+ "columnNames": [+ "staged_session_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_staged_session_id` ON `${TABLE_NAME}` (`staged_session_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_stalker_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_portal_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `working_endpoint` TEXT, `bootstrap_recipe` TEXT, `bulk_live_supported` INTEGER, `bulk_live_category_fidelity` INTEGER, `movie_wildcard_supported` INTEGER, `series_wildcard_supported` INTEGER, `epg_supported` INTEGER, `safe_metadata_concurrency` INTEGER NOT NULL, `stress_cooldown_until` INTEGER NOT NULL, `endpoint_health_json` TEXT NOT NULL, `endpoint_failed_until` INTEGER NOT NULL, `validated_at` INTEGER NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `learning_json` TEXT NOT NULL, `observation_source` TEXT NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "workingEndpoint",+ "columnName": "working_endpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bootstrapRecipe",+ "columnName": "bootstrap_recipe",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bulkLiveSupported",+ "columnName": "bulk_live_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "bulkLiveCategoryFidelity",+ "columnName": "bulk_live_category_fidelity",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "movieWildcardSupported",+ "columnName": "movie_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesWildcardSupported",+ "columnName": "series_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "epgSupported",+ "columnName": "epg_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "safeMetadataConcurrency",+ "columnName": "safe_metadata_concurrency",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stressCooldownUntil",+ "columnName": "stress_cooldown_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endpointHealthJson",+ "columnName": "endpoint_health_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "endpointFailedUntil",+ "columnName": "endpoint_failed_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "validatedAt",+ "columnName": "validated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "learningJson",+ "columnName": "learning_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observationSource",+ "columnName": "observation_source",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_portal_state_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_portal_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_remote_identities",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `raw_id` TEXT NOT NULL, `surrogate_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `raw_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rawId",+ "columnName": "raw_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surrogateId",+ "columnName": "surrogate_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "raw_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_remote_identities_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_remote_identities_provider_id_content_type_surrogate_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_type",+ "surrogate_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id_content_type_surrogate_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `surrogate_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_discovery_staging",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`discovery_id` TEXT NOT NULL, `provider_id` INTEGER, `configuration_generation` INTEGER NOT NULL, `sanitized_summary` TEXT NOT NULL, `categories_json` TEXT NOT NULL, `channels_json` TEXT NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`discovery_id`))",+ "fields": [+ {+ "fieldPath": "discoveryId",+ "columnName": "discovery_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sanitizedSummary",+ "columnName": "sanitized_summary",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoriesJson",+ "columnName": "categories_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelsJson",+ "columnName": "channels_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "discovery_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_discovery_staging_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_discovery_staging_created_at",+ "unique": false,+ "columnNames": [+ "created_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_created_at` ON `${TABLE_NAME}` (`created_at`)"+ }+ ]+ },+ {+ "tableName": "downloads",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `content_id` INTEGER NOT NULL, `content_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `source_stream_url` TEXT, `source_stream_id` INTEGER, `container_extension` TEXT, `poster_url` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `status` TEXT NOT NULL, `bytes_written` INTEGER NOT NULL, `total_bytes` INTEGER, `supports_resume` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `completed_at` INTEGER, `failure_reason` TEXT, `owner_id` TEXT, `owner_epoch` INTEGER NOT NULL, `heartbeat_at` INTEGER, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentName",+ "columnName": "content_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceStreamUrl",+ "columnName": "source_stream_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "sourceStreamId",+ "columnName": "source_stream_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalBytes",+ "columnName": "total_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "supportsResume",+ "columnName": "supports_resume",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerId",+ "columnName": "owner_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerEpoch",+ "columnName": "owner_epoch",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_downloads_status",+ "unique": false,+ "columnNames": [+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_status` ON `${TABLE_NAME}` (`status`)"+ },+ {+ "name": "index_downloads_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_downloads_content_type_content_id",+ "unique": false,+ "columnNames": [+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_content_type_content_id` ON `${TABLE_NAME}` (`content_type`, `content_id`)"+ }+ ]+ },+ {+ "tableName": "provider_deletion_cleanup",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `action` TEXT NOT NULL, `target_id` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "action",+ "columnName": "action",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_deletion_cleanup_provider_id_action_target_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "action",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_deletion_cleanup_provider_id_action_target_id` ON `${TABLE_NAME}` (`provider_id`, `action`, `target_id`)"+ }+ ]+ },+ {+ "tableName": "plugin_provider_ownership",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `service_class_name` TEXT NOT NULL, `manifest_id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`package_name`, `service_class_name`, `manifest_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "packageName",+ "columnName": "package_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "serviceClassName",+ "columnName": "service_class_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "manifestId",+ "columnName": "manifest_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "package_name",+ "service_class_name",+ "manifest_id"+ ]+ },+ "indices": [+ {+ "name": "index_plugin_provider_ownership_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_plugin_provider_ownership_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_config_revisions",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `revision` INTEGER NOT NULL, `config_json` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `revision`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "revision",+ "columnName": "revision",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configJson",+ "columnName": "config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "revision"+ ]+ },+ "indices": [+ {+ "name": "index_provider_config_revisions_provider_id_state",+ "unique": false,+ "columnNames": [+ "provider_id",+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_config_revisions_provider_id_state` ON `${TABLE_NAME}` (`provider_id`, `state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "backup_restore_checkpoints",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`restore_key` TEXT NOT NULL, `room_complete` INTEGER NOT NULL, `preferences_complete` INTEGER NOT NULL, `presets_complete` INTEGER NOT NULL, `schedules_complete` INTEGER NOT NULL, `state` TEXT NOT NULL, `preference_snapshot_json` TEXT, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`restore_key`))",+ "fields": [+ {+ "fieldPath": "restoreKey",+ "columnName": "restore_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "roomComplete",+ "columnName": "room_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "preferencesComplete",+ "columnName": "preferences_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "presetsComplete",+ "columnName": "presets_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schedulesComplete",+ "columnName": "schedules_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "preferenceSnapshotJson",+ "columnName": "preference_snapshot_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "restore_key"+ ]+ }+ },+ {+ "tableName": "backup_restore_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `restore_key` TEXT NOT NULL, `backup_version` INTEGER NOT NULL, `conflict_strategy` TEXT NOT NULL, `status` TEXT NOT NULL, `total_count` INTEGER NOT NULL, `pending_count` INTEGER NOT NULL, `applied_count` INTEGER NOT NULL, `unresolved_count` INTEGER NOT NULL, `failed_count` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "restoreKey",+ "columnName": "restore_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "backupVersion",+ "columnName": "backup_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "conflictStrategy",+ "columnName": "conflict_strategy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCount",+ "columnName": "total_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pendingCount",+ "columnName": "pending_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "appliedCount",+ "columnName": "applied_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "unresolvedCount",+ "columnName": "unresolved_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCount",+ "columnName": "failed_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_backup_restore_jobs_restore_key",+ "unique": true,+ "columnNames": [+ "restore_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_backup_restore_jobs_restore_key` ON `${TABLE_NAME}` (`restore_key`)"+ },+ {+ "name": "index_backup_restore_jobs_status",+ "unique": false,+ "columnNames": [+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_jobs_status` ON `${TABLE_NAME}` (`status`)"+ },+ {+ "name": "index_backup_restore_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ]+ },+ {+ "tableName": "backup_restore_items",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `job_id` TEXT NOT NULL, `provider_identity_key` TEXT NOT NULL, `local_provider_id` INTEGER, `section` TEXT NOT NULL, `content_type` TEXT, `stable_reference_key` TEXT NOT NULL, `reference_json` TEXT NOT NULL, `payload_json` TEXT NOT NULL, `status` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`job_id`) REFERENCES `backup_restore_jobs`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "jobId",+ "columnName": "job_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerIdentityKey",+ "columnName": "provider_identity_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "localProviderId",+ "columnName": "local_provider_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "stableReferenceKey",+ "columnName": "stable_reference_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "referenceJson",+ "columnName": "reference_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "payloadJson",+ "columnName": "payload_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_backup_restore_items_job_id",+ "unique": false,+ "columnNames": [+ "job_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_job_id` ON `${TABLE_NAME}` (`job_id`)"+ },+ {+ "name": "index_backup_restore_items_provider_identity_key_status",+ "unique": false,+ "columnNames": [+ "provider_identity_key",+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_provider_identity_key_status` ON `${TABLE_NAME}` (`provider_identity_key`, `status`)"+ },+ {+ "name": "index_backup_restore_items_job_id_status",+ "unique": false,+ "columnNames": [+ "job_id",+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_job_id_status` ON `${TABLE_NAME}` (`job_id`, `status`)"+ },+ {+ "name": "index_backup_restore_items_job_id_section_stable_reference_key",+ "unique": true,+ "columnNames": [+ "job_id",+ "section",+ "stable_reference_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_backup_restore_items_job_id_section_stable_reference_key` ON `${TABLE_NAME}` (`job_id`, `section`, `stable_reference_key`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "backup_restore_jobs",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "job_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_workflows",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `state` TEXT NOT NULL, `reason` TEXT NOT NULL, `priority` INTEGER NOT NULL, `force` INTEGER NOT NULL, `current_phase` TEXT, `lease_token` TEXT, `lease_expires_at` INTEGER, `heartbeat_at` INTEGER, `progress_message` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "reason",+ "columnName": "reason",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "force",+ "columnName": "force",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "currentPhase",+ "columnName": "current_phase",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseToken",+ "columnName": "lease_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseExpiresAt",+ "columnName": "lease_expires_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "progressMessage",+ "columnName": "progress_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflows_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflows_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_provider_workflows_lease_expires_at",+ "unique": false,+ "columnNames": [+ "lease_expires_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_lease_expires_at` ON `${TABLE_NAME}` (`lease_expires_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_workflow_phases",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `phase` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `checkpoint` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`, `generation`, `phase`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "checkpoint",+ "columnName": "checkpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "generation",+ "phase"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflow_phases_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_workflow_phases_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflow_phases_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_classification_overrides",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `source_key` TEXT NOT NULL, `stream_id` INTEGER NOT NULL, `target_type` TEXT NOT NULL, `group_key` TEXT NOT NULL, `series_key` TEXT, `series_name` TEXT, `season_number` INTEGER, `episode_number` INTEGER, `episode_title` TEXT, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `source_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceKey",+ "columnName": "source_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesKey",+ "columnName": "series_key",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesName",+ "columnName": "series_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeTitle",+ "columnName": "episode_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "source_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_classification_overrides_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_classification_overrides_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_category_classification_rules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `group_key` TEXT NOT NULL, `target_type` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `group_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "group_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_category_classification_rules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_category_classification_rules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ }+ ],+ "setupQueries": [+ "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",+ "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'bf6f92b8689ef564643e5c397acc582f')"+ ]+ }+}\ No newline at end of filediff --git a/data/schemas/com.streamvault.data.local.StreamVaultDatabase/81.json b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/81.jsonnew file mode 100644index 00000000..678d285a--- /dev/null+++ b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/81.json@@ -0,0 +1,7122 @@+{+ "formatVersion": 1,+ "database": {+ "version": 81,+ "identityHash": "bf6f92b8689ef564643e5c397acc582f",+ "entities": [+ {+ "tableName": "providers",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `type` TEXT NOT NULL, `is_active` INTEGER NOT NULL, `status` TEXT NOT NULL, `last_synced_at` INTEGER NOT NULL, `created_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "isActive",+ "columnName": "is_active",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncedAt",+ "columnName": "last_synced_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_providers_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_type` ON `${TABLE_NAME}` (`type`)"+ },+ {+ "name": "index_providers_is_active",+ "unique": false,+ "columnNames": [+ "is_active"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_is_active` ON `${TABLE_NAME}` (`is_active`)"+ }+ ]+ },+ {+ "tableName": "provider_configs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `type` TEXT NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `identity_key` TEXT NOT NULL, `encrypted_config_json` TEXT NOT NULL, `guide_source_policy` TEXT NOT NULL, `channel_logo_source_policy` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "identityKey",+ "columnName": "identity_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "encryptedConfigJson",+ "columnName": "encrypted_config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "guideSourcePolicy",+ "columnName": "guide_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelLogoSourcePolicy",+ "columnName": "channel_logo_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_configs_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_configs_identity_key",+ "unique": true,+ "columnNames": [+ "identity_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_identity_key` ON `${TABLE_NAME}` (`identity_key`)"+ },+ {+ "name": "index_provider_configs_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_configs_type` ON `${TABLE_NAME}` (`type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_account_runtime",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `max_connections` INTEGER NOT NULL, `expiration_date` INTEGER, `api_version` TEXT, `allowed_output_formats_json` TEXT NOT NULL, `catalog_layout` TEXT NOT NULL, `catalog_layout_detection_version` INTEGER NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "maxConnections",+ "columnName": "max_connections",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "expirationDate",+ "columnName": "expiration_date",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "apiVersion",+ "columnName": "api_version",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "allowedOutputFormatsJson",+ "columnName": "allowed_output_formats_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayout",+ "columnName": "catalog_layout",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayoutDetectionVersion",+ "columnName": "catalog_layout_detection_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_account_runtime_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_account_runtime_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `quality_options_json` TEXT, `playback_metadata_json` TEXT, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "qualityOptionsJson",+ "columnName": "quality_options_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channels_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_channels_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channels_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_channels_logical_group_id",+ "unique": false,+ "columnNames": [+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_logical_group_id` ON `${TABLE_NAME}` (`logical_group_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id_logical_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id_logical_group_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `logical_group_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_preferences",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `channel_id` INTEGER NOT NULL, `aspect_ratio` TEXT, `audio_video_offset_ms` INTEGER, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`channel_id`) REFERENCES `channels`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "aspectRatio",+ "columnName": "aspect_ratio",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "audioVideoOffsetMs",+ "columnName": "audio_video_offset_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_preferences_channel_id",+ "unique": true,+ "columnNames": [+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_preferences_channel_id` ON `${TABLE_NAME}` (`channel_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "channels",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "channel_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`channels`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "channels",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_UPDATE BEFORE UPDATE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_DELETE BEFORE DELETE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_UPDATE AFTER UPDATE ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_INSERT AFTER INSERT ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "movies",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `added_at` INTEGER NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, `playback_metadata_json` TEXT, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_movies_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movies_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_movies_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_movies_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_movies_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_added_at_release_date_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "added_at",+ "release_date",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_added_at_release_date_name_id` ON `${TABLE_NAME}` (`provider_id`, `added_at`, `release_date`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movies_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`movies`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "movies",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_UPDATE BEFORE UPDATE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_DELETE BEFORE DELETE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_UPDATE AFTER UPDATE ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_INSERT AFTER INSERT ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "series",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, `catalog_origin` TEXT NOT NULL, `episode_playback_template_url` TEXT, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catalogOrigin",+ "columnName": "catalog_origin",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodePlaybackTemplateUrl",+ "columnName": "episode_playback_template_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_series_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_series_provider_id_series_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_series_provider_id_series_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`)"+ },+ {+ "name": "index_series_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_last_modified_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "last_modified",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_last_modified_name_id` ON `${TABLE_NAME}` (`provider_id`, `last_modified`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`series`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "series",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_UPDATE BEFORE UPDATE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_DELETE BEFORE DELETE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_UPDATE AFTER UPDATE ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_INSERT AFTER INSERT ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "episodes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `episode_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `episode_number` INTEGER NOT NULL, `season_number` INTEGER NOT NULL, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `cover_url` TEXT, `plot` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `release_date` TEXT, `series_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`series_id`) REFERENCES `series`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "episodeId",+ "columnName": "episode_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "coverUrl",+ "columnName": "cover_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_episodes_series_id",+ "unique": false,+ "columnNames": [+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_series_id` ON `${TABLE_NAME}` (`series_id`)"+ },+ {+ "name": "index_episodes_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_episodes_provider_id_series_id_episode_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "series_id",+ "episode_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_episodes_provider_id_series_id_episode_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`, `episode_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "series",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "series_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "categories",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_categories_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_categories_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ },+ {+ "name": "index_categories_provider_id_category_id_type",+ "unique": true,+ "columnNames": [+ "provider_id",+ "category_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_categories_provider_id_category_id_type` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `is_adult` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `playback_metadata_json` TEXT, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channel_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `playback_metadata_json` TEXT, `added_at` INTEGER NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "playbackMetadataJson",+ "columnName": "playback_metadata_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movie_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `provider_series_key` TEXT NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `provider_series_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerSeriesKey",+ "columnName": "provider_series_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "provider_series_key"+ ]+ },+ "indices": [+ {+ "name": "index_series_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "category_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `category_id`, `type`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "category_id",+ "type"+ ]+ },+ "indices": [+ {+ "name": "index_category_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_category_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ },+ {+ "name": "index_category_import_stage_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "programs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `title` TEXT NOT NULL, `description` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `genre` TEXT, `category` TEXT, `has_archive` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "hasArchive",+ "columnName": "has_archive",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_programs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_programs_provider_id_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id` ON `${TABLE_NAME}` (`provider_id`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_end_time_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "end_time",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_end_time_channel_id` ON `${TABLE_NAME}` (`provider_id`, `end_time`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_start_time_end_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_programs_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_start_time` ON `${TABLE_NAME}` (`start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`, `end_time`)"+ }+ ]+ },+ {+ "tableName": "favorites",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `position` INTEGER NOT NULL, `group_id` INTEGER, `group_key` INTEGER NOT NULL, `added_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`group_id`) REFERENCES `virtual_groups`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupId",+ "columnName": "group_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_favorites_provider_id_content_id_content_type_group_key",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_id",+ "content_type",+ "group_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_favorites_provider_id_content_id_content_type_group_key` ON `${TABLE_NAME}` (`provider_id`, `content_id`, `content_type`, `group_key`)"+ },+ {+ "name": "index_favorites_provider_id_content_type_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_provider_id_content_type_group_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `group_id`)"+ },+ {+ "name": "index_favorites_group_id_position",+ "unique": false,+ "columnNames": [+ "group_id",+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_group_id_position` ON `${TABLE_NAME}` (`group_id`, `position`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "virtual_groups",+ "onDelete": "SET NULL",+ "onUpdate": "NO ACTION",+ "columns": [+ "group_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "virtual_groups",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `icon_emoji` TEXT, `position` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `content_type` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconEmoji",+ "columnName": "icon_emoji",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_virtual_groups_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_virtual_groups_position",+ "unique": false,+ "columnNames": [+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_position` ON `${TABLE_NAME}` (`position`)"+ },+ {+ "name": "index_virtual_groups_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_content_type` ON `${TABLE_NAME}` (`content_type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "playback_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `poster_url` TEXT, `stream_url` TEXT NOT NULL, `resume_position_ms` INTEGER NOT NULL, `total_duration_ms` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `watched_status` TEXT NOT NULL, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resumePositionMs",+ "columnName": "resume_position_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalDurationMs",+ "columnName": "total_duration_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchedStatus",+ "columnName": "watched_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_history_content_id_content_type_provider_id",+ "unique": true,+ "columnNames": [+ "content_id",+ "content_type",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_history_content_id_content_type_provider_id` ON `${TABLE_NAME}` (`content_id`, `content_type`, `provider_id`)"+ },+ {+ "name": "index_playback_history_last_watched_at",+ "unique": false,+ "columnNames": [+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_last_watched_at` ON `${TABLE_NAME}` (`last_watched_at`)"+ },+ {+ "name": "index_playback_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `content_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_last_watched_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_last_watched_at` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `last_watched_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "tmdb_identity",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tmdb_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `canonical_provider_id` INTEGER NOT NULL, `first_seen_at` INTEGER NOT NULL, PRIMARY KEY(`tmdb_id`, `content_type`), FOREIGN KEY(`canonical_provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "canonicalProviderId",+ "columnName": "canonical_provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "firstSeenAt",+ "columnName": "first_seen_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "tmdb_id",+ "content_type"+ ]+ },+ "indices": [+ {+ "name": "index_tmdb_identity_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_content_type` ON `${TABLE_NAME}` (`content_type`)"+ },+ {+ "name": "index_tmdb_identity_canonical_provider_id",+ "unique": false,+ "columnNames": [+ "canonical_provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_canonical_provider_id` ON `${TABLE_NAME}` (`canonical_provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "canonical_provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "search_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `query` TEXT NOT NULL, `content_scope` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `used_at` INTEGER NOT NULL, `use_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "query",+ "columnName": "query",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentScope",+ "columnName": "content_scope",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "usedAt",+ "columnName": "used_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "useCount",+ "columnName": "use_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_search_history_content_scope_provider_id_used_at",+ "unique": false,+ "columnNames": [+ "content_scope",+ "provider_id",+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_content_scope_provider_id_used_at` ON `${TABLE_NAME}` (`content_scope`, `provider_id`, `used_at`)"+ },+ {+ "name": "index_search_history_used_at",+ "unique": false,+ "columnNames": [+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_used_at` ON `${TABLE_NAME}` (`used_at`)"+ },+ {+ "name": "index_search_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_search_history_query_content_scope_provider_id",+ "unique": true,+ "columnNames": [+ "query",+ "content_scope",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_search_history_query_content_scope_provider_id` ON `${TABLE_NAME}` (`query`, `content_scope`, `provider_id`)"+ }+ ]+ },+ {+ "tableName": "sync_metadata",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `last_live_sync` INTEGER NOT NULL, `last_live_success` INTEGER NOT NULL, `last_movie_sync` INTEGER NOT NULL, `last_series_sync` INTEGER NOT NULL, `last_series_success` INTEGER NOT NULL, `last_epg_sync` INTEGER NOT NULL, `last_epg_success` INTEGER NOT NULL, `last_movie_attempt` INTEGER NOT NULL, `last_movie_success` INTEGER NOT NULL, `last_movie_partial` INTEGER NOT NULL, `live_count` INTEGER NOT NULL, `movie_count` INTEGER NOT NULL, `series_count` INTEGER NOT NULL, `epg_count` INTEGER NOT NULL, `last_sync_status` TEXT NOT NULL, `movie_sync_mode` TEXT NOT NULL, `movie_warnings_count` INTEGER NOT NULL, `movie_catalog_stale` INTEGER NOT NULL, `live_avoid_full_until` INTEGER NOT NULL, `movie_avoid_full_until` INTEGER NOT NULL, `series_avoid_full_until` INTEGER NOT NULL, `live_sequential_failures_remembered` INTEGER NOT NULL, `live_healthy_sync_streak` INTEGER NOT NULL, `movie_parallel_failures_remembered` INTEGER NOT NULL, `movie_healthy_sync_streak` INTEGER NOT NULL, `series_sequential_failures_remembered` INTEGER NOT NULL, `series_healthy_sync_streak` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSync",+ "columnName": "last_live_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSuccess",+ "columnName": "last_live_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSync",+ "columnName": "last_movie_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSync",+ "columnName": "last_series_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSuccess",+ "columnName": "last_series_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSync",+ "columnName": "last_epg_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSuccess",+ "columnName": "last_epg_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieAttempt",+ "columnName": "last_movie_attempt",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSuccess",+ "columnName": "last_movie_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMoviePartial",+ "columnName": "last_movie_partial",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveCount",+ "columnName": "live_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCount",+ "columnName": "movie_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesCount",+ "columnName": "series_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgCount",+ "columnName": "epg_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncStatus",+ "columnName": "last_sync_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieSyncMode",+ "columnName": "movie_sync_mode",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieWarningsCount",+ "columnName": "movie_warnings_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCatalogStale",+ "columnName": "movie_catalog_stale",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveAvoidFullUntil",+ "columnName": "live_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieAvoidFullUntil",+ "columnName": "movie_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesAvoidFullUntil",+ "columnName": "series_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveSequentialFailuresRemembered",+ "columnName": "live_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveHealthySyncStreak",+ "columnName": "live_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieParallelFailuresRemembered",+ "columnName": "movie_parallel_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieHealthySyncStreak",+ "columnName": "movie_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesSequentialFailuresRemembered",+ "columnName": "series_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesHealthySyncStreak",+ "columnName": "series_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_series_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `page_size` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `is_complete` INTEGER NOT NULL, `has_movies` INTEGER NOT NULL, `has_series` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasMovies",+ "columnName": "has_movies",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasSeries",+ "columnName": "has_series",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_catalog_entries",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `raw_item_id` TEXT NOT NULL, `item_type` TEXT NOT NULL, `target_id` INTEGER NOT NULL, `raw_page` INTEGER NOT NULL, `raw_index` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `category_id`, `raw_item_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawItemId",+ "columnName": "raw_item_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "itemType",+ "columnName": "item_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawPage",+ "columnName": "raw_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawIndex",+ "columnName": "raw_index",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_item_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_catalog_entries_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_page",+ "raw_index"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `raw_page`, `raw_index`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_item_type_target_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "item_type",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_item_type_target_id` ON `${TABLE_NAME}` (`provider_id`, `item_type`, `target_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `url` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `last_refresh_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `last_error` TEXT, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `etag` TEXT, `last_modified_header` TEXT, `timezone_policy` TEXT NOT NULL, `timezone_id` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "url",+ "columnName": "url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastRefreshAt",+ "columnName": "last_refresh_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "etag",+ "columnName": "etag",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModifiedHeader",+ "columnName": "last_modified_header",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "timezonePolicy",+ "columnName": "timezone_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "timezoneId",+ "columnName": "timezone_id",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_sources_url",+ "unique": true,+ "columnNames": [+ "url"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_sources_url` ON `${TABLE_NAME}` (`url`)"+ }+ ]+ },+ {+ "tableName": "provider_epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `epg_source_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_epg_sources_provider_id_epg_source_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_epg_sources_provider_id_epg_source_id` ON `${TABLE_NAME}` (`provider_id`, `epg_source_id`)"+ },+ {+ "name": "index_provider_epg_sources_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_epg_sources_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `display_name` TEXT NOT NULL, `normalized_name` TEXT NOT NULL, `icon_url` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "normalizedName",+ "columnName": "normalized_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconUrl",+ "columnName": "icon_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_channels_epg_source_id_xmltv_channel_id",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id_xmltv_channel_id` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`)"+ },+ {+ "name": "index_epg_channels_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_channels_normalized_name",+ "unique": false,+ "columnNames": [+ "normalized_name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_normalized_name` ON `${TABLE_NAME}` (`normalized_name`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_programmes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `title` TEXT NOT NULL, `subtitle` TEXT, `description` TEXT NOT NULL, `category` TEXT, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `episode_info` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "subtitle",+ "columnName": "subtitle",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeInfo",+ "columnName": "episode_info",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_programmes_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_start_time` ON `${TABLE_NAME}` (`start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_epg_mappings",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_channel_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `source_type` TEXT NOT NULL, `epg_source_id` INTEGER, `xmltv_channel_id` TEXT, `match_type` TEXT, `confidence` REAL NOT NULL, `matched_at` INTEGER NOT NULL, `failed_attempts` INTEGER NOT NULL, `source` TEXT, `is_manual_override` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerChannelId",+ "columnName": "provider_channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "matchType",+ "columnName": "match_type",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "confidence",+ "columnName": "confidence",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "matchedAt",+ "columnName": "matched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedAttempts",+ "columnName": "failed_attempts",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "source",+ "columnName": "source",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isManualOverride",+ "columnName": "is_manual_override",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_epg_mappings_provider_id_provider_channel_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "provider_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id_provider_channel_id` ON `${TABLE_NAME}` (`provider_id`, `provider_channel_id`)"+ },+ {+ "name": "index_channel_epg_mappings_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "combined_m3u_profiles",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "combined_m3u_profile_members",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `profile_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`profile_id`) REFERENCES `combined_m3u_profiles`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "profileId",+ "columnName": "profile_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_combined_m3u_profile_members_profile_id",+ "unique": false,+ "columnNames": [+ "profile_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id` ON `${TABLE_NAME}` (`profile_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_profile_id_provider_id",+ "unique": true,+ "columnNames": [+ "profile_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id_provider_id` ON `${TABLE_NAME}` (`profile_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "combined_m3u_profiles",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "profile_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_schedules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `requested_start_ms` INTEGER NOT NULL, `requested_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `enabled` INTEGER NOT NULL, `is_manual` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "requestedStartMs",+ "columnName": "requested_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "requestedEndMs",+ "columnName": "requested_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isManual",+ "columnName": "is_manual",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_schedules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_schedules_enabled_requested_start_ms",+ "unique": false,+ "columnNames": [+ "enabled",+ "requested_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_enabled_requested_start_ms` ON `${TABLE_NAME}` (`enabled`, `requested_start_ms`)"+ },+ {+ "name": "index_recording_schedules_recurring_rule_id",+ "unique": false,+ "columnNames": [+ "recurring_rule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_recurring_rule_id` ON `${TABLE_NAME}` (`recurring_rule_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_runs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `schedule_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `scheduled_start_ms` INTEGER NOT NULL, `scheduled_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `status` TEXT NOT NULL, `source_type` TEXT NOT NULL, `resolved_url` TEXT, `headers_json` TEXT NOT NULL, `user_agent` TEXT, `expiration_time` INTEGER, `provider_label` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `bytes_written` INTEGER NOT NULL, `average_throughput_bps` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `last_progress_at_ms` INTEGER, `failure_category` TEXT NOT NULL, `failure_reason` TEXT, `terminal_at_ms` INTEGER, `started_at_ms` INTEGER, `ended_at_ms` INTEGER, `schedule_enabled` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `alarm_start_at_ms` INTEGER, `alarm_stop_at_ms` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`schedule_id`) REFERENCES `recording_schedules`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "scheduleId",+ "columnName": "schedule_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "scheduledStartMs",+ "columnName": "scheduled_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "scheduledEndMs",+ "columnName": "scheduled_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolvedUrl",+ "columnName": "resolved_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "headersJson",+ "columnName": "headers_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "userAgent",+ "columnName": "user_agent",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "expirationTime",+ "columnName": "expiration_time",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "providerLabel",+ "columnName": "provider_label",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "averageThroughputBytesPerSecond",+ "columnName": "average_throughput_bps",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastProgressAtMs",+ "columnName": "last_progress_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureCategory",+ "columnName": "failure_category",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "terminalAtMs",+ "columnName": "terminal_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "startedAtMs",+ "columnName": "started_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "endedAtMs",+ "columnName": "ended_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "scheduleEnabled",+ "columnName": "schedule_enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "alarmStartAtMs",+ "columnName": "alarm_start_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "alarmStopAtMs",+ "columnName": "alarm_stop_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_runs_schedule_id",+ "unique": false,+ "columnNames": [+ "schedule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_schedule_id` ON `${TABLE_NAME}` (`schedule_id`)"+ },+ {+ "name": "index_recording_runs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_runs_status_scheduled_start_ms",+ "unique": false,+ "columnNames": [+ "status",+ "scheduled_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_status_scheduled_start_ms` ON `${TABLE_NAME}` (`status`, `scheduled_start_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_start_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_start_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_start_at_ms` ON `${TABLE_NAME}` (`alarm_start_at_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_stop_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_stop_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_stop_at_ms` ON `${TABLE_NAME}` (`alarm_stop_at_ms`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "recording_schedules",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "schedule_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "program_reminders",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `channel_name` TEXT NOT NULL, `program_title` TEXT NOT NULL, `program_start_time` INTEGER NOT NULL, `remind_at` INTEGER NOT NULL, `lead_time_minutes` INTEGER NOT NULL, `is_dismissed` INTEGER NOT NULL, `notified_at` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `delivery_state` TEXT NOT NULL, `delivery_attempt_token` TEXT, `delivery_attempted_at` INTEGER, `delivery_attempt_count` INTEGER NOT NULL, `delivery_failure_reason` TEXT, `created_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programStartTime",+ "columnName": "program_start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remindAt",+ "columnName": "remind_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "leadTimeMinutes",+ "columnName": "lead_time_minutes",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isDismissed",+ "columnName": "is_dismissed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "notifiedAt",+ "columnName": "notified_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryState",+ "columnName": "delivery_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deliveryAttemptToken",+ "columnName": "delivery_attempt_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "deliveryAttemptedAt",+ "columnName": "delivery_attempted_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "deliveryAttemptCount",+ "columnName": "delivery_attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryFailureReason",+ "columnName": "delivery_failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_program_reminders_provider_id_remind_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_remind_at` ON `${TABLE_NAME}` (`provider_id`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_is_dismissed_notified_at_remind_at",+ "unique": false,+ "columnNames": [+ "is_dismissed",+ "notified_at",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_is_dismissed_notified_at_remind_at` ON `${TABLE_NAME}` (`is_dismissed`, `notified_at`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_start_time`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_title_program_start_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_title",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_title_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_title`, `program_start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_storage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `tree_uri` TEXT, `display_name` TEXT, `output_directory` TEXT, `available_bytes` INTEGER, `is_writable` INTEGER NOT NULL, `file_name_pattern` TEXT NOT NULL, `retention_days` INTEGER, `max_simultaneous_recordings` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "treeUri",+ "columnName": "tree_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDirectory",+ "columnName": "output_directory",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "availableBytes",+ "columnName": "available_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isWritable",+ "columnName": "is_writable",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "fileNamePattern",+ "columnName": "file_name_pattern",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "retentionDays",+ "columnName": "retention_days",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "maxSimultaneousRecordings",+ "columnName": "max_simultaneous_recordings",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "playback_compatibility_records",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_fingerprint` TEXT NOT NULL, `device_model` TEXT NOT NULL, `android_sdk` INTEGER NOT NULL, `stream_type` TEXT NOT NULL, `video_mime_type` TEXT NOT NULL, `resolution_bucket` TEXT NOT NULL, `decoder_name` TEXT NOT NULL, `surface_type` TEXT NOT NULL, `failure_type` TEXT NOT NULL, `last_failed_at` INTEGER NOT NULL, `last_succeeded_at` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `success_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deviceFingerprint",+ "columnName": "device_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deviceModel",+ "columnName": "device_model",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "androidSdk",+ "columnName": "android_sdk",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamType",+ "columnName": "stream_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "videoMimeType",+ "columnName": "video_mime_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolutionBucket",+ "columnName": "resolution_bucket",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "decoderName",+ "columnName": "decoder_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surfaceType",+ "columnName": "surface_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureType",+ "columnName": "failure_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastFailedAt",+ "columnName": "last_failed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSucceededAt",+ "columnName": "last_succeeded_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "successCount",+ "columnName": "success_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type",+ "unique": true,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket",+ "decoder_name",+ "surface_type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`, `decoder_name`, `surface_type`)"+ },+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket",+ "unique": false,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`)"+ },+ {+ "name": "index_playback_compatibility_records_last_failed_at",+ "unique": false,+ "columnNames": [+ "last_failed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_failed_at` ON `${TABLE_NAME}` (`last_failed_at`)"+ },+ {+ "name": "index_playback_compatibility_records_last_succeeded_at",+ "unique": false,+ "columnNames": [+ "last_succeeded_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_succeeded_at` ON `${TABLE_NAME}` (`last_succeeded_at`)"+ }+ ]+ },+ {+ "tableName": "xtream_content_index",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `remote_id` TEXT NOT NULL, `local_content_id` INTEGER, `name` TEXT NOT NULL, `category_id` INTEGER, `category_name` TEXT, `image_url` TEXT, `container_extension` TEXT, `rating` REAL NOT NULL, `added_at` INTEGER NOT NULL, `remote_updated_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `indexed_at` INTEGER NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `stale_state` TEXT NOT NULL, `error_state` TEXT, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `remote_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "remoteId",+ "columnName": "remote_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "localContentId",+ "columnName": "local_content_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteUpdatedAt",+ "columnName": "remote_updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedAt",+ "columnName": "indexed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "staleState",+ "columnName": "stale_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorState",+ "columnName": "error_state",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "remote_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_content_index_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_category_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `category_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_name",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_name` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `name`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_local_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "local_content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_local_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `local_content_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_indexed_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "indexed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_indexed_at` ON `${TABLE_NAME}` (`provider_id`, `indexed_at`)"+ },+ {+ "name": "index_xtream_content_index_stale_state",+ "unique": false,+ "columnNames": [+ "stale_state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_stale_state` ON `${TABLE_NAME}` (`stale_state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `priority_category_id` INTEGER, `priority_requested_at` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priorityCategoryId",+ "columnName": "priority_category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "priorityRequestedAt",+ "columnName": "priority_requested_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_index_jobs_section",+ "unique": false,+ "columnNames": [+ "section"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_section` ON `${TABLE_NAME}` (`section`)"+ },+ {+ "name": "index_xtream_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_xtream_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_live_onboarding_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `provider_type` TEXT NOT NULL, `content_type` TEXT NOT NULL, `phase` TEXT NOT NULL, `staged_session_id` INTEGER, `import_strategy` TEXT, `next_category_index` INTEGER NOT NULL, `accepted_row_count` INTEGER NOT NULL, `staged_flush_count` INTEGER NOT NULL, `sealed_session_id` INTEGER, `sealed_row_count` INTEGER NOT NULL DEFAULT 0, `sealed_configuration_generation` INTEGER, `sealed_mapping_profile` TEXT, `sync_profile_tier` TEXT, `sync_profile_batch_size` INTEGER NOT NULL, `sync_profile_strategy` TEXT, `sync_profile_low_memory` INTEGER NOT NULL, `sync_profile_memory_class_mb` INTEGER NOT NULL, `sync_profile_available_mem_mb` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerType",+ "columnName": "provider_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "stagedSessionId",+ "columnName": "staged_session_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "importStrategy",+ "columnName": "import_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "acceptedRowCount",+ "columnName": "accepted_row_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stagedFlushCount",+ "columnName": "staged_flush_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sealedSessionId",+ "columnName": "sealed_session_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "sealedRowCount",+ "columnName": "sealed_row_count",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "sealedConfigurationGeneration",+ "columnName": "sealed_configuration_generation",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "sealedMappingProfile",+ "columnName": "sealed_mapping_profile",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileTier",+ "columnName": "sync_profile_tier",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileBatchSize",+ "columnName": "sync_profile_batch_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileStrategy",+ "columnName": "sync_profile_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileLowMemory",+ "columnName": "sync_profile_low_memory",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileMemoryClassMb",+ "columnName": "sync_profile_memory_class_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileAvailableMemMb",+ "columnName": "sync_profile_available_mem_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_live_onboarding_state_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_phase",+ "unique": false,+ "columnNames": [+ "phase"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_phase` ON `${TABLE_NAME}` (`phase`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_staged_session_id",+ "unique": false,+ "columnNames": [+ "staged_session_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_staged_session_id` ON `${TABLE_NAME}` (`staged_session_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_stalker_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_portal_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `working_endpoint` TEXT, `bootstrap_recipe` TEXT, `bulk_live_supported` INTEGER, `bulk_live_category_fidelity` INTEGER, `movie_wildcard_supported` INTEGER, `series_wildcard_supported` INTEGER, `epg_supported` INTEGER, `safe_metadata_concurrency` INTEGER NOT NULL, `stress_cooldown_until` INTEGER NOT NULL, `endpoint_health_json` TEXT NOT NULL, `endpoint_failed_until` INTEGER NOT NULL, `validated_at` INTEGER NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `learning_json` TEXT NOT NULL, `observation_source` TEXT NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "workingEndpoint",+ "columnName": "working_endpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bootstrapRecipe",+ "columnName": "bootstrap_recipe",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bulkLiveSupported",+ "columnName": "bulk_live_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "bulkLiveCategoryFidelity",+ "columnName": "bulk_live_category_fidelity",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "movieWildcardSupported",+ "columnName": "movie_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesWildcardSupported",+ "columnName": "series_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "epgSupported",+ "columnName": "epg_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "safeMetadataConcurrency",+ "columnName": "safe_metadata_concurrency",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stressCooldownUntil",+ "columnName": "stress_cooldown_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endpointHealthJson",+ "columnName": "endpoint_health_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "endpointFailedUntil",+ "columnName": "endpoint_failed_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "validatedAt",+ "columnName": "validated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "learningJson",+ "columnName": "learning_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observationSource",+ "columnName": "observation_source",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_portal_state_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_portal_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_remote_identities",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `raw_id` TEXT NOT NULL, `surrogate_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `raw_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rawId",+ "columnName": "raw_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surrogateId",+ "columnName": "surrogate_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "raw_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_remote_identities_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_remote_identities_provider_id_content_type_surrogate_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_type",+ "surrogate_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id_content_type_surrogate_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `surrogate_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_discovery_staging",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`discovery_id` TEXT NOT NULL, `provider_id` INTEGER, `configuration_generation` INTEGER NOT NULL, `sanitized_summary` TEXT NOT NULL, `categories_json` TEXT NOT NULL, `channels_json` TEXT NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`discovery_id`))",+ "fields": [+ {+ "fieldPath": "discoveryId",+ "columnName": "discovery_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sanitizedSummary",+ "columnName": "sanitized_summary",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoriesJson",+ "columnName": "categories_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelsJson",+ "columnName": "channels_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "discovery_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_discovery_staging_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_discovery_staging_created_at",+ "unique": false,+ "columnNames": [+ "created_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_created_at` ON `${TABLE_NAME}` (`created_at`)"+ }+ ]+ },+ {+ "tableName": "downloads",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `content_id` INTEGER NOT NULL, `content_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `source_stream_url` TEXT, `source_stream_id` INTEGER, `container_extension` TEXT, `poster_url` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `status` TEXT NOT NULL, `bytes_written` INTEGER NOT NULL, `total_bytes` INTEGER, `supports_resume` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `completed_at` INTEGER, `failure_reason` TEXT, `owner_id` TEXT, `owner_epoch` INTEGER NOT NULL, `heartbeat_at` INTEGER, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentName",+ "columnName": "content_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceStreamUrl",+ "columnName": "source_stream_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "sourceStreamId",+ "columnName": "source_stream_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalBytes",+ "columnName": "total_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "supportsResume",+ "columnName": "supports_resume",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerId",+ "columnName": "owner_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerEpoch",+ "columnName": "owner_epoch",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_downloads_status",+ "unique": false,+ "columnNames": [+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_status` ON `${TABLE_NAME}` (`status`)"+ },+ {+ "name": "index_downloads_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_downloads_content_type_content_id",+ "unique": false,+ "columnNames": [+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_content_type_content_id` ON `${TABLE_NAME}` (`content_type`, `content_id`)"+ }+ ]+ },+ {+ "tableName": "provider_deletion_cleanup",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `action` TEXT NOT NULL, `target_id` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "action",+ "columnName": "action",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_deletion_cleanup_provider_id_action_target_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "action",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_deletion_cleanup_provider_id_action_target_id` ON `${TABLE_NAME}` (`provider_id`, `action`, `target_id`)"+ }+ ]+ },+ {+ "tableName": "plugin_provider_ownership",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `service_class_name` TEXT NOT NULL, `manifest_id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`package_name`, `service_class_name`, `manifest_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "packageName",+ "columnName": "package_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "serviceClassName",+ "columnName": "service_class_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "manifestId",+ "columnName": "manifest_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "package_name",+ "service_class_name",+ "manifest_id"+ ]+ },+ "indices": [+ {+ "name": "index_plugin_provider_ownership_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_plugin_provider_ownership_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_config_revisions",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `revision` INTEGER NOT NULL, `config_json` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `revision`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "revision",+ "columnName": "revision",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configJson",+ "columnName": "config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "revision"+ ]+ },+ "indices": [+ {+ "name": "index_provider_config_revisions_provider_id_state",+ "unique": false,+ "columnNames": [+ "provider_id",+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_config_revisions_provider_id_state` ON `${TABLE_NAME}` (`provider_id`, `state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "backup_restore_checkpoints",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`restore_key` TEXT NOT NULL, `room_complete` INTEGER NOT NULL, `preferences_complete` INTEGER NOT NULL, `presets_complete` INTEGER NOT NULL, `schedules_complete` INTEGER NOT NULL, `state` TEXT NOT NULL, `preference_snapshot_json` TEXT, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`restore_key`))",+ "fields": [+ {+ "fieldPath": "restoreKey",+ "columnName": "restore_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "roomComplete",+ "columnName": "room_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "preferencesComplete",+ "columnName": "preferences_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "presetsComplete",+ "columnName": "presets_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schedulesComplete",+ "columnName": "schedules_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "preferenceSnapshotJson",+ "columnName": "preference_snapshot_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "restore_key"+ ]+ }+ },+ {+ "tableName": "backup_restore_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `restore_key` TEXT NOT NULL, `backup_version` INTEGER NOT NULL, `conflict_strategy` TEXT NOT NULL, `status` TEXT NOT NULL, `total_count` INTEGER NOT NULL, `pending_count` INTEGER NOT NULL, `applied_count` INTEGER NOT NULL, `unresolved_count` INTEGER NOT NULL, `failed_count` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "restoreKey",+ "columnName": "restore_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "backupVersion",+ "columnName": "backup_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "conflictStrategy",+ "columnName": "conflict_strategy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCount",+ "columnName": "total_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pendingCount",+ "columnName": "pending_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "appliedCount",+ "columnName": "applied_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "unresolvedCount",+ "columnName": "unresolved_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCount",+ "columnName": "failed_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_backup_restore_jobs_restore_key",+ "unique": true,+ "columnNames": [+ "restore_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_backup_restore_jobs_restore_key` ON `${TABLE_NAME}` (`restore_key`)"+ },+ {+ "name": "index_backup_restore_jobs_status",+ "unique": false,+ "columnNames": [+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_jobs_status` ON `${TABLE_NAME}` (`status`)"+ },+ {+ "name": "index_backup_restore_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ]+ },+ {+ "tableName": "backup_restore_items",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `job_id` TEXT NOT NULL, `provider_identity_key` TEXT NOT NULL, `local_provider_id` INTEGER, `section` TEXT NOT NULL, `content_type` TEXT, `stable_reference_key` TEXT NOT NULL, `reference_json` TEXT NOT NULL, `payload_json` TEXT NOT NULL, `status` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`job_id`) REFERENCES `backup_restore_jobs`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "jobId",+ "columnName": "job_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerIdentityKey",+ "columnName": "provider_identity_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "localProviderId",+ "columnName": "local_provider_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "stableReferenceKey",+ "columnName": "stable_reference_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "referenceJson",+ "columnName": "reference_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "payloadJson",+ "columnName": "payload_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_backup_restore_items_job_id",+ "unique": false,+ "columnNames": [+ "job_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_job_id` ON `${TABLE_NAME}` (`job_id`)"+ },+ {+ "name": "index_backup_restore_items_provider_identity_key_status",+ "unique": false,+ "columnNames": [+ "provider_identity_key",+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_provider_identity_key_status` ON `${TABLE_NAME}` (`provider_identity_key`, `status`)"+ },+ {+ "name": "index_backup_restore_items_job_id_status",+ "unique": false,+ "columnNames": [+ "job_id",+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_backup_restore_items_job_id_status` ON `${TABLE_NAME}` (`job_id`, `status`)"+ },+ {+ "name": "index_backup_restore_items_job_id_section_stable_reference_key",+ "unique": true,+ "columnNames": [+ "job_id",+ "section",+ "stable_reference_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_backup_restore_items_job_id_section_stable_reference_key` ON `${TABLE_NAME}` (`job_id`, `section`, `stable_reference_key`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "backup_restore_jobs",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "job_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_workflows",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `state` TEXT NOT NULL, `reason` TEXT NOT NULL, `priority` INTEGER NOT NULL, `force` INTEGER NOT NULL, `current_phase` TEXT, `lease_token` TEXT, `lease_expires_at` INTEGER, `heartbeat_at` INTEGER, `progress_message` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "reason",+ "columnName": "reason",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "force",+ "columnName": "force",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "currentPhase",+ "columnName": "current_phase",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseToken",+ "columnName": "lease_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseExpiresAt",+ "columnName": "lease_expires_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "progressMessage",+ "columnName": "progress_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflows_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflows_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_provider_workflows_lease_expires_at",+ "unique": false,+ "columnNames": [+ "lease_expires_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_lease_expires_at` ON `${TABLE_NAME}` (`lease_expires_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_workflow_phases",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `phase` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `checkpoint` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`, `generation`, `phase`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "checkpoint",+ "columnName": "checkpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "generation",+ "phase"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflow_phases_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_workflow_phases_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflow_phases_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_classification_overrides",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `source_key` TEXT NOT NULL, `stream_id` INTEGER NOT NULL, `target_type` TEXT NOT NULL, `group_key` TEXT NOT NULL, `series_key` TEXT, `series_name` TEXT, `season_number` INTEGER, `episode_number` INTEGER, `episode_title` TEXT, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `source_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceKey",+ "columnName": "source_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesKey",+ "columnName": "series_key",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesName",+ "columnName": "series_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeTitle",+ "columnName": "episode_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "source_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_classification_overrides_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_classification_overrides_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_category_classification_rules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `group_key` TEXT NOT NULL, `target_type` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `group_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "group_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_category_classification_rules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_category_classification_rules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ }+ ],+ "setupQueries": [+ "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",+ "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'bf6f92b8689ef564643e5c397acc582f')"+ ]+ }+}\ No newline at end of filediff --git a/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV78To79.kt b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV78To79.ktnew file mode 100644index 00000000..cefcb90d--- /dev/null+++ b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV78To79.kt@@ -0,0 +1,18 @@+package com.streamvault.data.local++import androidx.room.migration.Migration+import androidx.sqlite.db.SupportSQLiteDatabase++/** Scopes episode uniqueness to its owning series and expires the old series-detail TTL. */+object FeatureMigrationsV78To79 {+ val MIGRATION_78_79 = object : Migration(78, 79) {+ override fun migrate(db: SupportSQLiteDatabase) {+ db.execSQL("DROP INDEX IF EXISTS index_episodes_provider_id_episode_id")+ db.execSQL(+ "CREATE UNIQUE INDEX IF NOT EXISTS index_episodes_provider_id_series_id_episode_id " ++ "ON episodes(provider_id, series_id, episode_id)"+ )+ db.execSQL("UPDATE series SET detail_hydrated_at = 1 WHERE detail_hydrated_at > 0")+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV79To80.kt b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV79To80.ktnew file mode 100644index 00000000..22109e1c--- /dev/null+++ b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV79To80.kt@@ -0,0 +1,38 @@+package com.streamvault.data.local++import androidx.room.migration.Migration+import androidx.sqlite.db.SupportSQLiteDatabase++/** Adds durable receipt fields for staged Xtream live onboarding sessions. */+internal object FeatureMigrationsV79To80 {+ val MIGRATION_79_80 = object : Migration(79, 80) {+ override fun migrate(db: SupportSQLiteDatabase) {+ val columns = db.query("PRAGMA table_info(xtream_live_onboarding_state)").use { cursor ->+ buildSet {+ val nameColumn = cursor.getColumnIndexOrThrow("name")+ while (cursor.moveToNext()) add(cursor.getString(nameColumn))+ }+ }+ if ("sealed_session_id" !in columns) {+ db.execSQL("ALTER TABLE xtream_live_onboarding_state ADD COLUMN sealed_session_id INTEGER")+ }+ if ("sealed_row_count" !in columns) {+ db.execSQL(+ "ALTER TABLE xtream_live_onboarding_state " ++ "ADD COLUMN sealed_row_count INTEGER NOT NULL DEFAULT 0"+ )+ }+ if ("sealed_configuration_generation" !in columns) {+ db.execSQL(+ "ALTER TABLE xtream_live_onboarding_state " ++ "ADD COLUMN sealed_configuration_generation INTEGER"+ )+ }+ if ("sealed_mapping_profile" !in columns) {+ db.execSQL(+ "ALTER TABLE xtream_live_onboarding_state ADD COLUMN sealed_mapping_profile TEXT"+ )+ }+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV80To81.kt b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV80To81.ktnew file mode 100644index 00000000..0bbf1aa0--- /dev/null+++ b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV80To81.kt@@ -0,0 +1,44 @@+package com.streamvault.data.local++import androidx.room.migration.Migration+import androidx.sqlite.db.SupportSQLiteDatabase++/** Repairs databases created by an older build that reused schema version 80 for an earlier layout. */+internal object FeatureMigrationsV80To81 {+ val MIGRATION_80_81 = object : Migration(80, 81) {+ override fun migrate(db: SupportSQLiteDatabase) {+ val onboardingColumns = db.query("PRAGMA table_info(xtream_live_onboarding_state)").use { cursor ->+ buildSet {+ val nameColumn = cursor.getColumnIndexOrThrow("name")+ while (cursor.moveToNext()) add(cursor.getString(nameColumn))+ }+ }+ if ("sealed_session_id" !in onboardingColumns) {+ db.execSQL("ALTER TABLE xtream_live_onboarding_state ADD COLUMN sealed_session_id INTEGER")+ }+ if ("sealed_row_count" !in onboardingColumns) {+ db.execSQL(+ "ALTER TABLE xtream_live_onboarding_state " ++ "ADD COLUMN sealed_row_count INTEGER NOT NULL DEFAULT 0"+ )+ }+ if ("sealed_configuration_generation" !in onboardingColumns) {+ db.execSQL(+ "ALTER TABLE xtream_live_onboarding_state " ++ "ADD COLUMN sealed_configuration_generation INTEGER"+ )+ }+ if ("sealed_mapping_profile" !in onboardingColumns) {+ db.execSQL("ALTER TABLE xtream_live_onboarding_state ADD COLUMN sealed_mapping_profile TEXT")+ }++ db.execSQL("DROP INDEX IF EXISTS index_episodes_provider_id_episode_id")+ db.execSQL(+ "CREATE UNIQUE INDEX IF NOT EXISTS index_episodes_provider_id_series_id_episode_id " ++ "ON episodes(provider_id, series_id, episode_id)"+ )+ // Force a refresh after correcting legacy episode identity so old partial season data is repaired.+ db.execSQL("UPDATE series SET detail_hydrated_at = 1 WHERE detail_hydrated_at > 0")+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.ktindex 70b6db8c..88bf3f97 100644--- a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt+++ b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt@@ -12,7 +12,7 @@ import org.json.JSONObjectimport java.net.URIimport java.security.MessageDigest-internal const val STREAM_VAULT_DATABASE_VERSION = 78+internal const val STREAM_VAULT_DATABASE_VERSION = 81@Database(entities = [@@ -206,5 +206,8 @@ abstract class StreamVaultDatabase : RoomDatabase() {val MIGRATION_75_76 = FeatureMigrationsV75To76.MIGRATION_75_76val MIGRATION_76_77 = FeatureMigrationsV76To77.MIGRATION_76_77val MIGRATION_77_78 = FeatureMigrationsV77To78.MIGRATION_77_78+ val MIGRATION_78_79 = FeatureMigrationsV78To79.MIGRATION_78_79+ val MIGRATION_79_80 = FeatureMigrationsV79To80.MIGRATION_79_80+ val MIGRATION_80_81 = FeatureMigrationsV80To81.MIGRATION_80_81}}diff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.ktindex fe49f49f..c97af8be 100644--- a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt+++ b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt@@ -15,7 +15,10 @@ object StreamVaultDatabaseMigrationRegistry {val v75To76: List<Migration> = listOf(FeatureMigrationsV75To76.MIGRATION_75_76)val v76To77: List<Migration> = listOf(FeatureMigrationsV76To77.MIGRATION_76_77)val v77To78: List<Migration> = listOf(FeatureMigrationsV77To78.MIGRATION_77_78)- val all: List<Migration> = (v1To24 + v24To49 + v49To75 + v75To76 + v76To77 + v77To78).also(::validate)+ val v78To79: List<Migration> = listOf(FeatureMigrationsV78To79.MIGRATION_78_79)+ val v79To80: List<Migration> = listOf(FeatureMigrationsV79To80.MIGRATION_79_80)+ val v80To81: List<Migration> = listOf(FeatureMigrationsV80To81.MIGRATION_80_81)+ val all: List<Migration> = (v1To24 + v24To49 + v49To75 + v75To76 + v76To77 + v77To78 + v78To79 + v79To80 + v80To81).also(::validate)private fun validate(migrations: List<Migration>) {require(migrations.map { it.startVersion }.distinct().size == migrations.size) {diff --git a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt b/data/src/main/java/com/streamvault/data/local/dao/Daos.ktindex e9973d1f..37c7dfae 100644--- a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt+++ b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt@@ -976,6 +976,12 @@ interface TmdbIdentityDao {@Dao@RewriteQueriesToDropUnusedColumnsinterface MovieDao {+ @Query("SELECT * FROM movies WHERE id IN (:ids) AND provider_id > 0")+ suspend fun getByIdsSync(ids: List<Long>): List<MovieEntity>+ @Query("SELECT * FROM movies WHERE tmdb_id IN (:ids) AND provider_id > 0")+ suspend fun getByTmdbIdsSync(ids: List<Long>): List<MovieEntity>+ @Query("SELECT * FROM movies WHERE provider_id = :providerId AND tmdb_id IN (:ids)")+ suspend fun getByProviderTmdbIdsSync(providerId: Long, ids: List<Long>): List<MovieEntity>@Query("SELECT * FROM movies WHERE provider_id = :providerId ORDER BY added_at DESC, name ASC, id ASC")fun getByProvider(providerId: Long): Flow<List<MovieBrowseEntity>>@@ -1880,6 +1886,12 @@ interface MovieDao {@Dao@RewriteQueriesToDropUnusedColumnsinterface SeriesDao {+ @Query("SELECT * FROM series WHERE id IN (:ids) AND provider_id > 0")+ suspend fun getByIdsSync(ids: List<Long>): List<SeriesEntity>+ @Query("SELECT * FROM series WHERE tmdb_id IN (:ids) AND provider_id > 0")+ suspend fun getByTmdbIdsSync(ids: List<Long>): List<SeriesEntity>+ @Query("SELECT * FROM series WHERE provider_id = :providerId AND tmdb_id IN (:ids)")+ suspend fun getByProviderTmdbIdsSync(providerId: Long, ids: List<Long>): List<SeriesEntity>@Query("SELECT * FROM series WHERE provider_id = :providerId ORDER BY last_modified DESC, name ASC, id ASC")fun getByProvider(providerId: Long): Flow<List<SeriesBrowseEntity>>@@ -2901,6 +2913,7 @@ interface EpisodeDao {AND playback_history.provider_id = episodes.provider_idWHERE episodes.provider_id = :providerIdAND episodes.series_id = :seriesId+ AND COALESCE(playback_history.watched_status, 'IN_PROGRESS') = 'IN_PROGRESS'AND (COALESCE(playback_history.total_duration_ms, episodes.duration_seconds * 1000) <= 0OR COALESCE(playback_history.resume_position_ms, episodes.watch_progress) < CAST(@@ -3524,9 +3537,12 @@ interface VirtualGroupDao {@Dao@RewriteQueriesToDropUnusedColumnsinterface PlaybackHistoryDao {- @Query("SELECT * FROM playback_history ORDER BY last_watched_at DESC LIMIT :limit")+ @Query("SELECT * FROM playback_history ORDER BY last_watched_at DESC, content_id DESC, content_type DESC, provider_id DESC LIMIT :limit")fun getRecentlyWatched(limit: Int = 100): Flow<List<PlaybackHistoryLiteEntity>>+ @Query("SELECT * FROM playback_history ORDER BY last_watched_at DESC, content_id DESC, content_type DESC, provider_id DESC LIMIT :limit OFFSET :offset")+ fun getRecentlyWatchedPage(limit: Int, offset: Int): Flow<List<PlaybackHistoryLiteEntity>>+@Query("SELECT * FROM playback_history WHERE provider_id = :providerId ORDER BY last_watched_at DESC LIMIT :limit")fun getRecentlyWatchedByProvider(providerId: Long, limit: Int = 100): Flow<List<PlaybackHistoryLiteEntity>>diff --git a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt b/data/src/main/java/com/streamvault/data/local/entity/Entities.ktindex fb0a4f17..c1806839 100644--- a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt+++ b/data/src/main/java/com/streamvault/data/local/entity/Entities.kt@@ -513,7 +513,7 @@ data class SeriesFtsEntity(indices = [Index(value = ["series_id"]),Index(value = ["provider_id"]),- Index(value = ["provider_id", "episode_id"], unique = true)+ Index(value = ["provider_id", "series_id", "episode_id"], unique = true)])data class EpisodeEntity(diff --git a/data/src/main/java/com/streamvault/data/local/entity/XtreamLiveOnboardingEntities.kt b/data/src/main/java/com/streamvault/data/local/entity/XtreamLiveOnboardingEntities.ktindex 367f94b6..ebeb39f9 100644--- a/data/src/main/java/com/streamvault/data/local/entity/XtreamLiveOnboardingEntities.kt+++ b/data/src/main/java/com/streamvault/data/local/entity/XtreamLiveOnboardingEntities.kt@@ -31,6 +31,10 @@ data class XtreamLiveOnboardingStateEntity(@ColumnInfo(name = "next_category_index") val nextCategoryIndex: Int = 0,@ColumnInfo(name = "accepted_row_count") val acceptedRowCount: Int = 0,@ColumnInfo(name = "staged_flush_count") val stagedFlushCount: Int = 0,+ @ColumnInfo(name = "sealed_session_id") val sealedSessionId: Long? = null,+ @ColumnInfo(name = "sealed_row_count", defaultValue = "0") val sealedRowCount: Int = 0,+ @ColumnInfo(name = "sealed_configuration_generation") val sealedConfigurationGeneration: Long? = null,+ @ColumnInfo(name = "sealed_mapping_profile") val sealedMappingProfile: String? = null,@ColumnInfo(name = "sync_profile_tier") val syncProfileTier: String? = null,@ColumnInfo(name = "sync_profile_batch_size") val syncProfileBatchSize: Int = 0,@ColumnInfo(name = "sync_profile_strategy") val syncProfileStrategy: String? = null,@@ -41,4 +45,4 @@ data class XtreamLiveOnboardingStateEntity(@ColumnInfo(name = "created_at") val createdAt: Long = 0L,@ColumnInfo(name = "updated_at") val updatedAt: Long = 0L,@ColumnInfo(name = "completed_at") val completedAt: Long? = null-)\ No newline at end of file+)diff --git a/data/src/main/java/com/streamvault/data/manager/PreferenceBackupRegistry.kt b/data/src/main/java/com/streamvault/data/manager/PreferenceBackupRegistry.ktindex 8eadd142..3439bae9 100644--- a/data/src/main/java/com/streamvault/data/manager/PreferenceBackupRegistry.kt+++ b/data/src/main/java/com/streamvault/data/manager/PreferenceBackupRegistry.kt@@ -18,7 +18,10 @@ internal object PreferenceBackupRegistry {"show_recent_channels_category", "live_tv_category_filters", "live_tv_quick_filter_visibility","hide_decorative_live_rows", "live_channel_numbering_mode", "live_channel_grouping_mode","grouped_channel_label_mode", "live_variant_preference_mode", "live_variant_selections",- "vod_view_mode", "vod_type_badge_as_icon", "vod_infinite_scroll", "vod_portal_search", "vod_category_load_mode", "vod_duplicate_handling_mode",+ "vod_view_mode", "vod_type_badge_as_icon", "vod_infinite_scroll", "vod_portal_search",+ "show_trakt_trending_movies", "show_trakt_popular_movies", "show_trakt_trending_series",+ "show_trakt_popular_series", "trakt_scrobbling_enabled", "trakt_history_sync_enabled",+ "vod_category_load_mode", "vod_duplicate_handling_mode","vod_variant_preference_mode", "vod_variant_selections", "guide_density", "guide_channel_mode","guide_default_category_id", "guide_favorites_only", "guide_anchor_time","epg_time_shift_by_provider", "promoted_live_group_ids", "multiview_preset_1",@@ -96,7 +99,10 @@ internal object PreferenceBackupRegistry {"liveTvAutoHideCategories","showLiveSourceSwitcher", "showFavoritesCategory", "showAllChannelsCategory", "showRecentChannelsCategory","hideDecorativeLiveRows", "liveChannelNumberingMode", "liveChannelGroupingMode", "groupedChannelLabelMode",- "liveVariantPreferenceMode", "vodViewMode", "vodTypeBadgeAsIcon", "vodInfiniteScroll", "vodPortalSearch", "vodCategoryLoadMode",+ "liveVariantPreferenceMode", "vodViewMode", "vodTypeBadgeAsIcon", "vodInfiniteScroll", "vodPortalSearch",+ "showTraktTrendingMovies", "showTraktPopularMovies", "showTraktTrendingSeries", "showTraktPopularSeries",+ "traktScrobblingEnabled", "traktHistorySyncEnabled",+ "vodCategoryLoadMode","vodDuplicateHandlingMode", "vodVariantPreferenceMode", "playerMediaSessionEnabled", "playerBackButtonVisibility","playerConfirmClosePlayback","playerFastRetryOnTransientFailures", "playerAudioDecoderMode", "playerVideoDecoderMode",diff --git a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.ktindex c9ec99e4..efd788a0 100644--- a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt+++ b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt@@ -59,6 +59,7 @@ import com.streamvault.domain.model.TimeshiftBackendPreferenceimport com.streamvault.domain.manager.ParentalPinVerifierimport com.streamvault.domain.manager.ParentalControlSessionStateimport com.streamvault.domain.manager.ParentalControlSessionStore+import com.streamvault.domain.trakt.TraktFeaturePreferencesimport java.security.SecureRandomimport javax.crypto.SecretKeyFactoryimport javax.crypto.spec.PBEKeySpec@@ -167,7 +168,7 @@ class PreferencesRepository @Inject constructor(private val channelPreferenceDao: ChannelPreferenceDao,private val searchHistoryDao: SearchHistoryDao,private val corruptionRecovery: PreferencesCorruptionRecovery-) : ParentalControlSessionStore, ParentalPinVerifier, PlayerPreferences {+) : ParentalControlSessionStore, ParentalPinVerifier, PlayerPreferences, TraktFeaturePreferences {private val preferencesDataStore: DataStore<Preferences> by lazy {PreferenceDataStoreFactory.create(corruptionHandler = ReplaceFileCorruptionHandler { cause ->@@ -226,6 +227,12 @@ class PreferencesRepository @Inject constructor(val VOD_TYPE_BADGE_AS_ICON = booleanPreferencesKey("vod_type_badge_as_icon")val VOD_INFINITE_SCROLL = booleanPreferencesKey("vod_infinite_scroll")val VOD_PORTAL_SEARCH = booleanPreferencesKey("vod_portal_search")+ val SHOW_TRAKT_TRENDING_MOVIES = booleanPreferencesKey("show_trakt_trending_movies")+ val SHOW_TRAKT_POPULAR_MOVIES = booleanPreferencesKey("show_trakt_popular_movies")+ val SHOW_TRAKT_TRENDING_SERIES = booleanPreferencesKey("show_trakt_trending_series")+ val SHOW_TRAKT_POPULAR_SERIES = booleanPreferencesKey("show_trakt_popular_series")+ val TRAKT_SCROBBLING_ENABLED = booleanPreferencesKey("trakt_scrobbling_enabled")+ val TRAKT_HISTORY_SYNC_ENABLED = booleanPreferencesKey("trakt_history_sync_enabled")val VOD_CATEGORY_LOAD_MODE = stringPreferencesKey("vod_category_load_mode")val VOD_DUPLICATE_HANDLING_MODE = stringPreferencesKey("vod_duplicate_handling_mode")val VOD_VARIANT_PREFERENCE_MODE = stringPreferencesKey("vod_variant_preference_mode")@@ -2037,6 +2044,66 @@ class PreferencesRepository @Inject constructor(}}+ override val showTraktTrendingMovies: Flow<Boolean> = context.dataStore.data.map { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_TRENDING_MOVIES] ?: true+ }++ override suspend fun setShowTraktTrendingMovies(enabled: Boolean) {+ context.dataStore.edit { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_TRENDING_MOVIES] = enabled+ }+ }++ override val showTraktPopularMovies: Flow<Boolean> = context.dataStore.data.map { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_POPULAR_MOVIES] ?: true+ }++ override suspend fun setShowTraktPopularMovies(enabled: Boolean) {+ context.dataStore.edit { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_POPULAR_MOVIES] = enabled+ }+ }++ override val showTraktTrendingSeries: Flow<Boolean> = context.dataStore.data.map { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_TRENDING_SERIES] ?: true+ }++ override suspend fun setShowTraktTrendingSeries(enabled: Boolean) {+ context.dataStore.edit { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_TRENDING_SERIES] = enabled+ }+ }++ override val showTraktPopularSeries: Flow<Boolean> = context.dataStore.data.map { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_POPULAR_SERIES] ?: true+ }++ override suspend fun setShowTraktPopularSeries(enabled: Boolean) {+ context.dataStore.edit { preferences ->+ preferences[PreferencesKeys.SHOW_TRAKT_POPULAR_SERIES] = enabled+ }+ }++ override val scrobblingEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->+ preferences[PreferencesKeys.TRAKT_SCROBBLING_ENABLED] ?: true+ }++ override suspend fun setScrobblingEnabled(enabled: Boolean) {+ context.dataStore.edit { preferences ->+ preferences[PreferencesKeys.TRAKT_SCROBBLING_ENABLED] = enabled+ }+ }++ override val historySyncEnabled: Flow<Boolean> = context.dataStore.data.map { preferences ->+ preferences[PreferencesKeys.TRAKT_HISTORY_SYNC_ENABLED] ?: true+ }++ override suspend fun setHistorySyncEnabled(enabled: Boolean) {+ context.dataStore.edit { preferences ->+ preferences[PreferencesKeys.TRAKT_HISTORY_SYNC_ENABLED] = enabled+ }+ }+override val vodCategoryLoadMode: Flow<com.streamvault.domain.model.VodCategoryLoadMode> =context.dataStore.data.map { preferences ->com.streamvault.domain.model.VodCategoryLoadMode.fromStorage(diff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.ktindex 0a9c7b82..5136ff33 100644--- a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt+++ b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt@@ -173,6 +173,18 @@ class MovieRepositoryImpl @Inject constructor(buildPresentedMovies(list.map { it.toDomain() }, settings)}.flowOn(Dispatchers.Default)+ override suspend fun getMoviesByTmdbIds(providerId: Long, tmdbIds: List<Long>): List<Movie> {+ val ids = tmdbIds.asSequence().filter { it > 0L }.distinct().toList()+ if (ids.isEmpty()) return emptyList()+ val hideProtected = preferencesRepository.parentalControlLevel.first() >= 3+ val rows = ids.chunked(400).flatMap { movieDao.getByProviderTmdbIdsSync(providerId, it) }+ .asSequence()+ .filterNot { hideProtected && it.isUserProtected }+ .map { it.toDomain() }+ .toList()+ return buildPresentedMovies(rows, moviePresentationSettingsFlow.first())+ }+override fun getMoviesByCategory(providerId: Long, categoryId: Long): Flow<List<Movie>> =flow {ensureXtreamCategoryLoaded(providerId, categoryId, fetchIfMissing = true, refreshStaleInBackground = true)diff --git a/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.ktindex 51b55080..b6b56326 100644--- a/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt+++ b/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt@@ -27,6 +27,7 @@ import kotlinx.coroutines.flow.combineimport kotlinx.coroutines.flow.mapimport kotlinx.coroutines.flow.SharingStartedimport kotlinx.coroutines.flow.StateFlow+import kotlinx.coroutines.flow.firstimport kotlinx.coroutines.flow.stateInimport kotlinx.coroutines.isActiveimport kotlinx.coroutines.sync.Mutex@@ -70,6 +71,8 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(}}+ override suspend fun isIncognitoModeEnabled(): Boolean = preferencesRepository.isIncognitoMode.first()+override fun getRecentlyWatched(limit: Int): Flow<List<PlaybackHistory>> {return mergedRecentHistory(persisted = dao.getRecentlyWatched(limit).map { list -> list.map { it.toDomain() } },@@ -77,6 +80,15 @@ class PlaybackHistoryRepositoryImpl @Inject constructor() { true }}+ override suspend fun getRecentlyWatchedPage(offset: Int, limit: Int): List<PlaybackHistory> {+ require(offset >= 0)+ require(limit > 0)+ return pendingProgressMutex.withLock {+ flushPendingResumeUpdatesLocked()+ dao.getRecentlyWatchedPage(limit = limit, offset = offset).first().map { it.toDomain() }+ }+ }+override fun getRecentlyWatchedByProvider(providerId: Long, limit: Int): Flow<List<PlaybackHistory>> {return mergedRecentHistory(persisted = dao.getRecentlyWatchedByProvider(providerId, limit).map { list -> list.map { it.toDomain() } },@@ -170,6 +182,33 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(}}+ override suspend fun importTraktHistory(history: PlaybackHistory,+ identity: com.streamvault.domain.trakt.TraktMediaIdentity,+ match: com.streamvault.domain.trakt.TraktHistoryMatch): Result<Boolean> {+ return try {+ if (preferencesRepository.isIncognitoMode.first()) return Result.success(false)+ pendingProgressMutex.withLock {+ val key = history.playbackKey()+ val didImport = transactionRunner.inTransaction {+ val existing = pendingResumeUpdates[key]+ ?: dao.get(history.contentId, history.contentType.name, history.providerId)?.toDomain()+ val candidate = com.streamvault.domain.trakt.TraktHistoryMergePolicy.importCandidate(+ existing ?: history, identity, match) ?: return@inTransaction false+ val imported = candidate.copy(streamUrl = XtreamUrlFactory.sanitizePersistedStreamUrl(candidate.streamUrl, candidate.providerId))+ dao.insertOrUpdate(imported.toEntity())+ syncDenormalizedProgress(imported.contentId, imported.contentType, imported.providerId)+ true+ }+ if (didImport) clearPendingResumeUpdateLocked(key)+ Result.success(didImport)+ }+ } catch (cancelled: CancellationException) {+ throw cancelled+ } catch (failure: Exception) {+ Result.error("Failed to import Trakt history", failure)+ }+ }+override suspend fun recordPlayback(history: PlaybackHistory): Result<Unit> {return try {if (isIncognito.value) {@@ -313,22 +352,26 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(private suspend fun flushPendingResumeUpdates() {pendingProgressMutex.withLock {- val snapshot = pendingResumeUpdates.toMap()- if (snapshot.isEmpty()) return@withLock+ flushPendingResumeUpdatesLocked()+ }+ }- // One transaction for the coalesced set avoids a Room transaction per content- // item when a lifecycle boundary flushes several recently played items.- transactionRunner.inTransaction {- snapshot.values.forEach { history ->- dao.insertOrUpdate(history.toEntity())- syncDenormalizedProgress(history.contentId, history.contentType, history.providerId)- }- }- snapshot.forEach { (key, history) ->- pendingResumeUpdates.remove(key, history)+ private suspend fun flushPendingResumeUpdatesLocked() {+ val snapshot = pendingResumeUpdates.toMap()+ if (snapshot.isEmpty()) return++ // One transaction for the coalesced set avoids a Room transaction per content+ // item when a lifecycle boundary flushes several recently played items.+ transactionRunner.inTransaction {+ snapshot.values.forEach { history ->+ dao.insertOrUpdate(history.toEntity())+ syncDenormalizedProgress(history.contentId, history.contentType, history.providerId)}- publishPendingResumeUpdates()}+ snapshot.forEach { (key, history) ->+ pendingResumeUpdates.remove(key, history)+ }+ publishPendingResumeUpdates()}private fun clearPendingResumeUpdateLocked(key: PlaybackKey) {@@ -357,7 +400,12 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(mergedByKey[history.playbackKey()] = history}mergedByKey.values- .sortedByDescending(PlaybackHistory::lastWatchedAt)+ .sortedWith(+ compareByDescending<PlaybackHistory> { it.lastWatchedAt }+ .thenByDescending { it.contentId }+ .thenByDescending { it.contentType.name }+ .thenByDescending { it.providerId }+ ).take(limit)}diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.ktindex 127f88f4..16a79fae 100644--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt@@ -155,6 +155,18 @@ class SeriesRepositoryImpl @Inject constructor(buildPresentedSeries(list, settings)}.flowOn(Dispatchers.Default)+ override suspend fun getSeriesByTmdbIds(providerId: Long, tmdbIds: List<Long>): List<Series> {+ val ids = tmdbIds.asSequence().filter { it > 0L }.distinct().toList()+ if (ids.isEmpty()) return emptyList()+ val hideProtected = preferencesRepository.parentalControlLevel.first() >= 3+ val rows = ids.chunked(400).flatMap { seriesDao.getByProviderTmdbIdsSync(providerId, it) }+ .asSequence()+ .filterNot { hideProtected && it.isUserProtected }+ .map { it.toDomain() }+ .toList()+ return buildPresentedSeries(rows, seriesPresentationSettingsFlow.first())+ }+override fun getSeriesByCategory(providerId: Long, categoryId: Long): Flow<List<Series>> =flow {ensureXtreamCategoryLoaded(providerId, categoryId)diff --git a/data/src/main/java/com/streamvault/data/trakt/EncryptedTraktTokenStore.kt b/data/src/main/java/com/streamvault/data/trakt/EncryptedTraktTokenStore.ktnew file mode 100644index 00000000..5598a04b--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/EncryptedTraktTokenStore.kt@@ -0,0 +1,35 @@+package com.streamvault.data.trakt++import android.content.Context+import android.util.AtomicFile+import com.google.gson.Gson+import com.streamvault.data.security.CredentialCrypto+import java.io.File++/** Separate from app backups; the verifier also survives browser-induced process death. */+class EncryptedTraktTokenStore(context: Context, private val crypto: CredentialCrypto) : TraktTokenStore {+ private val file = AtomicFile(File(context.noBackupFilesDir, "trakt_session"))+ private val gson = Gson()++ @Synchronized override fun read(): TraktStoredSession {+ if (!file.baseFile.exists()) return TraktStoredSession()+ return gson.fromJson(crypto.decryptIfNeeded(file.openRead().bufferedReader().use { it.readText() }),+ TraktStoredSession::class.java) ?: TraktStoredSession()+ }++ @Synchronized override fun write(session: TraktStoredSession) {+ if (session.tokens == null && session.pending == null) {+ file.delete()+ return+ }+ val encrypted = crypto.encryptIfNeeded(gson.toJson(session))+ val stream = file.startWrite()+ try {+ stream.write(encrypted.toByteArray(Charsets.UTF_8))+ file.finishWrite(stream)+ } catch (failure: Exception) {+ file.failWrite(stream)+ throw failure+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktApiClient.kt b/data/src/main/java/com/streamvault/data/trakt/TraktApiClient.ktnew file mode 100644index 00000000..7430fbf3--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktApiClient.kt@@ -0,0 +1,549 @@+package com.streamvault.data.trakt++import com.google.gson.Gson+import com.google.gson.JsonObject+import com.google.gson.JsonArray+import com.streamvault.domain.trakt.TraktMediaIdentity+import com.streamvault.domain.trakt.TraktScrobbleEvent+import com.streamvault.domain.trakt.TraktHistoryEntry+import com.streamvault.domain.trakt.TraktHistoryPage+import com.streamvault.domain.trakt.TraktHistoryUpload+import com.streamvault.domain.trakt.TraktHistoryUploadResult+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistPage+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoritePage+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktUserProfile+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingPage+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktCustomList+import com.streamvault.domain.trakt.TraktCustomListItem+import com.streamvault.domain.trakt.TraktCustomListItemIdentity+import com.streamvault.domain.trakt.TraktCustomListItemType+import com.streamvault.domain.trakt.TraktCustomListItemsPage+import com.streamvault.domain.trakt.TraktDiscoveryCategory+import com.streamvault.domain.trakt.TraktDiscoveryPage+import java.time.Instant+import java.time.temporal.ChronoUnit+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.withContext+import kotlinx.coroutines.delay+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import java.time.ZonedDateTime+import java.time.format.DateTimeFormatter+import okhttp3.HttpUrl+import okhttp3.HttpUrl.Companion.toHttpUrl+import okhttp3.MediaType.Companion.toMediaType+import okhttp3.OkHttpClient+import okhttp3.Request+import okhttp3.RequestBody.Companion.toRequestBody++/** Dedicated client without provider interceptors, disk cache, or body logging. */+class TraktApiClient(+ private val config: TraktConfig,+ private val client: OkHttpClient,+ private val baseUrl: HttpUrl = "https://api.trakt.tv/".toHttpUrl(),+ private val userAgent: String = "StreamVault",+) : TraktApi, TraktPlaybackApi, TraktHistoryApi, TraktWatchlistApi, TraktFavoritesApi, TraktRatingsApi,+ TraktCustomListsApi, TraktDiscoveryApi {+ private val gson = Gson()+ private val requestMutex = Mutex()+ private var nextRequestAt = 0L+ private var lastWriteAt = 0L+ private var rateLimitFailures = 0+ private val episodeIds = object : LinkedHashMap<TraktMediaIdentity.EpisodeId, Long>(128, .75f, true) {+ override fun removeEldestEntry(eldest: MutableMap.MutableEntry<TraktMediaIdentity.EpisodeId, Long>?) = size > 128+ }++ override suspend fun history(accessToken: String, page: Int): TraktHistoryPage {+ require(page in 1..10000)+ var pageCount: Int? = null+ val response = request("sync/history?page=$page&limit=100", accessToken,+ observeHeaders = { pageCount = it["X-Pagination-Page-Count"]?.toIntOrNull()?.takeIf { count -> count >= 0 } })+ val rows = gson.fromJson(response, JsonArray::class.java)+ var skipped = 0+ val entries = rows.mapNotNull { row ->+ runCatching {+ val item = row.asJsonObject+ val id = item["id"].asString.toLong()+ val watchedAt = Instant.parse(item["watched_at"].asString).toEpochMilli()+ val identity = when (item["type"].asString) {+ "movie" -> TraktMediaIdentity.MovieId(item.getAsJsonObject("movie").getAsJsonObject("ids")["tmdb"].asString.toLong())+ "episode" -> TraktMediaIdentity.EpisodeId(+ item.getAsJsonObject("show").getAsJsonObject("ids")["tmdb"].asString.toLong(),+ item.getAsJsonObject("episode")["season"].asString.toInt(),+ item.getAsJsonObject("episode")["number"].asString.toInt())+ else -> error("Unsupported history media")+ }+ TraktHistoryEntry(id, identity, watchedAt)+ }.getOrElse { skipped++; null }+ }+ return TraktHistoryPage(entries, page, pageCount?.let { page < it } ?: (rows.size() >= 100), skipped)+ }++ override suspend fun watchlist(accessToken: String, type: TraktWatchlistType, page: Int): TraktWatchlistPage {+ require(page in 1..10000)+ var pageCount: Int? = null+ val response = request("sync/watchlist/${type.apiPath}?page=$page&limit=100", accessToken,+ observeHeaders = { pageCount = it["X-Pagination-Page-Count"]?.toIntOrNull()?.takeIf { count -> count >= 0 } })+ val rows = gson.fromJson(response, JsonArray::class.java)+ var skipped = 0+ val items = rows.mapNotNull { row ->+ runCatching {+ val wrapper = row.asJsonObject+ val media = wrapper.getAsJsonObject(if (type == TraktWatchlistType.MOVIE) "movie" else "show")+ ?: error("Missing watchlist item")+ val tmdbId = media.getAsJsonObject("ids")?.get("tmdb")?.takeUnless { it.isJsonNull }+ ?.asString?.toLongOrNull()+ ?.takeIf { it > 0 } ?: error("Missing TMDB id")+ TraktWatchlistIdentity(type, tmdbId)+ }.getOrElse { skipped++; null }+ }+ return TraktWatchlistPage(items, page, pageCount?.let { page < it } ?: (rows.size() >= 100), skipped)+ }++ override suspend fun discover(category: TraktDiscoveryCategory, page: Int): TraktDiscoveryPage {+ require(page in 1..10000)+ val response = request("${category.media.apiPath}/${category.kind.apiPath}?page=$page&limit=$DISCOVERY_PAGE_SIZE")+ val rows = gson.fromJson(response, JsonArray::class.java)+ var skipped = 0+ val tmdbIds = rows.mapNotNull { row ->+ runCatching {+ val entry = row.asJsonObject+ // Trending wraps media with watcher metadata; popular returns the media object directly.+ val mediaKey = if (category.media == com.streamvault.domain.trakt.TraktDiscoveryMedia.MOVIE) "movie" else "show"+ val media = entry.getAsJsonObject(mediaKey) ?: entry+ media.getAsJsonObject("ids")?.get("tmdb")?.takeUnless { it.isJsonNull }+ ?.asString?.toLongOrNull()?.takeIf { it > 0L } ?: error("Missing TMDB id")+ }.getOrElse { skipped++; null }+ }.distinct().take(DISCOVERY_PAGE_SIZE)+ return TraktDiscoveryPage(tmdbIds, skipped)+ }++ override suspend fun setWatchlisted(+ accessToken: String,+ identity: TraktWatchlistIdentity,+ watchlisted: Boolean,+ ) {+ val mediaKey = if (identity.type == TraktWatchlistType.MOVIE) "movies" else "shows"+ val payload = mapOf(mediaKey to listOf(mapOf("ids" to mapOf("tmdb" to identity.tmdbId))))+ val path = if (watchlisted) "sync/watchlist" else "sync/watchlist/remove"+ request(path, accessToken, payload)+ }++ override suspend fun setFavorited(+ accessToken: String,+ identity: TraktFavoriteIdentity,+ favorited: Boolean,+ ) {+ val payload = mapOf(identity.type.payloadKey to listOf(mapOf("ids" to mapOf("tmdb" to identity.tmdbId))))+ val path = if (favorited) "sync/favorites" else "sync/favorites/remove"+ request(path, accessToken, payload)+ }++ override suspend fun favorites(+ accessToken: String,+ type: TraktFavoriteType,+ page: Int,+ ): TraktFavoritePage {+ require(page in 1..MAX_SYNC_PAGES)+ var pageCount: Int? = null+ val rows = gson.fromJson(+ request("sync/favorites/${type.apiPath}?page=$page&limit=$SYNC_PAGE_SIZE", accessToken,+ observeHeaders = { pageCount = it["X-Pagination-Page-Count"]?.toIntOrNull()?.takeIf { count -> count >= 0 } }),+ JsonArray::class.java,+ )+ var skipped = 0+ val items = rows.mapNotNull { row ->+ runCatching {+ val wrapper = row.asJsonObject+ val media = wrapper.getAsJsonObject(type.responseKey) ?: error("Missing favorite item")+ val tmdbId = media.getAsJsonObject("ids")?.get("tmdb")?.takeUnless { it.isJsonNull }+ ?.asString?.toLongOrNull()?.takeIf { it > 0L } ?: error("Missing TMDB id")+ TraktFavoriteIdentity(type, tmdbId)+ }.getOrElse { skipped++; null }+ }.distinct()+ return TraktFavoritePage(+ identities = items,+ page = page,+ hasMore = pageCount?.let { page < it } ?: (rows.size() >= SYNC_PAGE_SIZE),+ skippedItems = skipped,+ )+ }++ override suspend fun ratings(accessToken: String, type: TraktRatingType, page: Int): TraktRatingPage {+ require(page in 1..10000)+ var pageCount: Int? = null+ val response = request("users/me/ratings/${type.apiPath}?page=$page&limit=100", accessToken,+ observeHeaders = { pageCount = it["X-Pagination-Page-Count"]?.toIntOrNull()?.takeIf { count -> count >= 0 } })+ val rows = gson.fromJson(response, JsonArray::class.java)+ var skipped = 0+ val items = rows.mapNotNull { row ->+ runCatching {+ val item = row.asJsonObject+ require(item["type"]?.asString == type.responseKey)+ val rating = item["rating"]?.asInt?.takeIf { it in 1..10 } ?: error("Invalid rating")+ val media = item.getAsJsonObject(type.responseKey) ?: error("Missing rated media")+ val tmdbId = media.getAsJsonObject("ids")?.get("tmdb")?.takeUnless { it.isJsonNull }+ ?.asString?.toLongOrNull()?.takeIf { it > 0L } ?: error("Missing TMDB id")+ TraktRatingIdentity(type, tmdbId) to rating+ }.getOrElse { skipped++; null }+ }+ return TraktRatingPage(items, page, pageCount?.let { page < it } ?: (rows.size() >= 100), skipped)+ }++ override suspend fun setRating(+ accessToken: String,+ identity: TraktRatingIdentity,+ rating: Int,+ ) {+ require(rating in 1..10)+ val ratedAt = Instant.now().truncatedTo(ChronoUnit.SECONDS).toString()+ val item = mapOf("rating" to rating, "rated_at" to ratedAt,+ "ids" to mapOf("tmdb" to identity.tmdbId))+ request("sync/ratings", accessToken, mapOf(identity.type.payloadKey to listOf(item)))+ }++ override suspend fun lists(accessToken: String): List<TraktCustomList> {+ val rows = gson.fromJson(request("users/me/lists", accessToken), JsonArray::class.java)+ return rows.mapNotNull { row ->+ runCatching {+ val item = row.asJsonObject+ val ids = item.getAsJsonObject("ids") ?: error("Missing list ids")+ val id = ids.get("trakt")?.takeUnless { it.isJsonNull }?.asLong?.takeIf { it > 0L }+ ?: error("Missing list id")+ val name = item.get("name")?.takeUnless { it.isJsonNull }?.asString?.trim()+ ?.takeIf { it.isNotEmpty() } ?: error("Missing list name")+ TraktCustomList(+ id = id,+ name = name,+ description = item.get("description")?.takeUnless { it.isJsonNull }?.asString+ ?.trim()?.takeIf { it.isNotEmpty() },+ privacy = item.get("privacy")?.takeUnless { it.isJsonNull }?.asString ?: "private",+ itemCount = item.get("item_count")?.takeUnless { it.isJsonNull }?.asInt+ ?.coerceAtLeast(0) ?: 0,+ )+ }.getOrNull()+ }.distinctBy { it.id }+ }++ override suspend fun items(+ accessToken: String,+ listId: Long,+ type: TraktCustomListItemType,+ page: Int,+ ): TraktCustomListItemsPage {+ require(listId > 0L && page in 1..10000)+ var pageCount: Int? = null+ val response = request("users/me/lists/$listId/items/${type.apiPath}?page=$page&limit=$CUSTOM_LIST_PAGE_SIZE&extended=full",+ accessToken, observeHeaders = {+ pageCount = it["X-Pagination-Page-Count"]?.toIntOrNull()?.takeIf { count -> count >= 0 }+ })+ val rows = gson.fromJson(response, JsonArray::class.java)+ var skipped = 0+ val parsed = rows.mapNotNull { row ->+ runCatching {+ val wrapper = row.asJsonObject+ val media = wrapper.getAsJsonObject(type.responseKey) ?: error("Missing list media")+ fun positiveId(obj: JsonObject, key: String): Long? = obj.getAsJsonObject("ids")+ ?.get(key)?.takeUnless { it.isJsonNull }?.let { runCatching { it.asLong }.getOrNull() }+ ?.takeIf { it > 0L }+ val (identity, title) = when (type) {+ TraktCustomListItemType.MOVIE, TraktCustomListItemType.SHOW -> {+ val tmdbId = positiveId(media, "tmdb") ?: error("Missing TMDB id")+ val title = media.get("title")?.takeUnless { it.isJsonNull }?.asString+ ?.trim()?.takeIf { it.isNotEmpty() } ?: error("Missing title")+ TraktCustomListItemIdentity(type, tmdbId) to title+ }+ TraktCustomListItemType.SEASON, TraktCustomListItemType.EPISODE -> {+ val show = wrapper.getAsJsonObject("show") ?: media.getAsJsonObject("show")+ ?: error("Missing parent show")+ val showTmdbId = positiveId(show, "tmdb") ?: error("Missing parent show TMDB id")+ val showTitle = show.get("title")?.takeUnless { it.isJsonNull }?.asString+ ?.trim()?.takeIf { it.isNotEmpty() } ?: error("Missing parent show title")+ if (type == TraktCustomListItemType.SEASON) {+ val season = media.get("number")?.takeUnless { it.isJsonNull }?.asInt+ ?.takeIf { it >= 0 } ?: error("Missing season number")+ TraktCustomListItemIdentity(type, showTmdbId, season) to "$showTitle · Season $season"+ } else {+ val season = media.get("season")?.takeUnless { it.isJsonNull }?.asInt+ ?.takeIf { it >= 0 } ?: error("Missing episode season")+ val number = media.get("number")?.takeUnless { it.isJsonNull }?.asInt+ ?.takeIf { it > 0 } ?: error("Missing episode number")+ val episodeTitle = media.get("title")?.takeUnless { it.isJsonNull }?.asString+ ?.trim()?.takeIf { it.isNotEmpty() } ?: "Episode $number"+ TraktCustomListItemIdentity(type, showTmdbId, season, number) to+ "$showTitle · S${season}E${number} · $episodeTitle"+ }+ }+ }+ TraktCustomListItem(+ identity = identity,+ title = title,+ year = media.get("year")?.takeUnless { it.isJsonNull }?.asInt?.takeIf { it in 1800..3000 },+ rank = wrapper.get("rank")?.takeUnless { it.isJsonNull }?.asInt?.takeIf { it > 0 },+ listItemId = wrapper.get("id")?.takeUnless { it.isJsonNull }+ ?.let { runCatching { it.asLong }.getOrNull() }?.takeIf { it > 0L },+ )+ }.getOrElse { skipped++; null }+ }+ return TraktCustomListItemsPage(+ items = parsed,+ page = page,+ hasMore = pageCount?.let { page < it } ?: (rows.size() >= CUSTOM_LIST_PAGE_SIZE),+ skippedItems = skipped,+ )+ }++ override suspend fun createList(+ accessToken: String,+ name: String,+ description: String?,+ ): TraktCustomList {+ require(name.isNotBlank())+ val payload = buildMap<String, Any> {+ put("name", name.trim())+ put("privacy", "private")+ description?.trim()?.takeIf { it.isNotEmpty() }?.let { put("description", it) }+ }+ val result = gson.fromJson(request("users/me/lists", accessToken, payload), JsonObject::class.java)+ val ids = result.getAsJsonObject("ids") ?: error("Missing created list ids")+ val id = ids.get("trakt")?.takeUnless { it.isJsonNull }?.asLong?.takeIf { it > 0L }+ ?: error("Missing created list id")+ return TraktCustomList(+ id = id,+ name = result.get("name")?.takeUnless { it.isJsonNull }?.asString?.trim()+ ?.takeIf { it.isNotEmpty() } ?: name.trim(),+ description = result.get("description")?.takeUnless { it.isJsonNull }?.asString+ ?.trim()?.takeIf { it.isNotEmpty() } ?: description?.trim()?.takeIf { it.isNotEmpty() },+ privacy = result.get("privacy")?.takeUnless { it.isJsonNull }?.asString ?: "private",+ itemCount = result.get("item_count")?.takeUnless { it.isJsonNull }?.asInt?.coerceAtLeast(0) ?: 0,+ )+ }++ override suspend fun deleteList(accessToken: String, listId: Long) {+ require(listId > 0L)+ request("users/me/lists/$listId", accessToken, httpMethod = "DELETE")+ }++ override suspend fun reorderLists(accessToken: String, listIds: List<Long>) {+ require(listIds.isNotEmpty() && listIds.all { it > 0L } && listIds.distinct().size == listIds.size)+ request("users/me/lists/reorder", accessToken, mapOf("rank" to listIds))+ }++ override suspend fun reorderItems(accessToken: String, listId: Long, listItemIds: List<Long>) {+ require(listId > 0L && listItemIds.isNotEmpty() && listItemIds.all { it > 0L } &&+ listItemIds.distinct().size == listItemIds.size)+ request("users/me/lists/$listId/items/reorder", accessToken, mapOf("rank" to listItemIds))+ }++ override suspend fun setItem(+ accessToken: String,+ listId: Long,+ identity: TraktCustomListItemIdentity,+ included: Boolean,+ ) {+ require(listId > 0L)+ val ids = when (identity.type) {+ TraktCustomListItemType.MOVIE, TraktCustomListItemType.SHOW -> mapOf("tmdb" to identity.tmdbId)+ TraktCustomListItemType.SEASON -> {+ val showTraktId = resolveShowTraktId(accessToken, identity.tmdbId)+ ?: error("Could not match the show to Trakt")+ val seasonNumber = requireNotNull(identity.seasonNumber)+ val season = gson.fromJson(+ request("shows/$showTraktId/seasons/$seasonNumber", accessToken), JsonObject::class.java,+ )+ require(season.get("number")?.asInt == seasonNumber) { "Trakt returned a different season" }+ val seasonTraktId = season.getAsJsonObject("ids")?.get("trakt")?.takeUnless { it.isJsonNull }+ ?.asLong?.takeIf { it > 0L } ?: error("Trakt season id is missing")+ mapOf("trakt" to seasonTraktId)+ }+ TraktCustomListItemType.EPISODE -> {+ val episodeTraktId = resolveEpisodeTraktId(accessToken,+ TraktMediaIdentity.EpisodeId(identity.tmdbId, requireNotNull(identity.seasonNumber),+ requireNotNull(identity.episodeNumber))) ?: error("Could not match the episode to Trakt")+ mapOf("trakt" to episodeTraktId)+ }+ }+ val payload = mapOf(identity.type.payloadKey to listOf(mapOf("ids" to ids)))+ val path = "users/me/lists/$listId/items" + if (included) "" else "/remove"+ request(path, accessToken, payload)+ }++ override suspend fun scrobble(accessToken: String, event: TraktScrobbleEvent): Boolean {+ val media = when (val identity = event.media) {+ is TraktMediaIdentity.MovieId -> "movie" to mapOf("ids" to mapOf("tmdb" to identity.tmdbId))+ is TraktMediaIdentity.EpisodeId -> {+ val episodeId = resolveEpisodeTraktId(accessToken, identity) ?: return false+ "episode" to mapOf("ids" to mapOf("trakt" to episodeId))+ }+ }+ request("scrobble/${event.action.name.lowercase(java.util.Locale.ROOT)}", accessToken,+ mapOf(media, "progress" to event.progress))+ return true+ }++ override suspend fun upload(accessToken: String, events: List<TraktHistoryUpload>): TraktHistoryUploadResult {+ if (events.isEmpty()) return TraktHistoryUploadResult.Success(uploaded = 0)+ val movies = mutableListOf<Map<String, Any>>()+ val episodes = mutableListOf<Map<String, Any>>()+ var unmatched = 0+ for (event in events.distinctBy { it.media to (it.watchedAtMs / 60_000) }) {+ val watchedAt = Instant.ofEpochMilli(event.watchedAtMs).truncatedTo(ChronoUnit.MINUTES).toString()+ when (val media = event.media) {+ is TraktMediaIdentity.MovieId -> movies += mapOf(+ "watched_at" to watchedAt,+ "ids" to mapOf("tmdb" to media.tmdbId),+ )+ is TraktMediaIdentity.EpisodeId -> {+ val episodeId = resolveEpisodeTraktId(accessToken, media)+ if (episodeId == null) unmatched++ else episodes += mapOf(+ "watched_at" to watchedAt,+ "ids" to mapOf("trakt" to episodeId),+ )+ }+ }+ }+ if (movies.isEmpty() && episodes.isEmpty()) return TraktHistoryUploadResult.Success(0, unmatched)+ val payload = buildMap<String, Any> {+ if (movies.isNotEmpty()) put("movies", movies)+ if (episodes.isNotEmpty()) put("episodes", episodes)+ }+ val response = gson.fromJson(request("sync/history", accessToken, payload), JsonObject::class.java)+ val added = response.getAsJsonObject("added")+ val updated = response.getAsJsonObject("updated")+ val notFound = response.getAsJsonObject("not_found")+ val accepted = count(added, "movies") + count(added, "episodes") ++ count(updated, "movies") + count(updated, "episodes")+ val rejected = notFound?.let { countArray(it, "movies") + countArray(it, "episodes") } ?: 0+ return TraktHistoryUploadResult.Success(accepted, unmatched + rejected)+ }++ private suspend fun resolveEpisodeTraktId(accessToken: String, identity: TraktMediaIdentity.EpisodeId): Long? {+ synchronized(episodeIds) { episodeIds[identity] }?.let { return it }+ val showId = resolveShowTraktId(accessToken, identity.showTmdbId) ?: return null+ val episode = gson.fromJson(request("shows/$showId/seasons/${identity.season}/episodes/${identity.number}", accessToken), JsonObject::class.java)+ if (episode["season"]?.asInt != identity.season || episode["number"]?.asInt != identity.number) return null+ val id = episode.getAsJsonObject("ids")?.get("trakt")?.takeUnless { it.isJsonNull }?.asLong?.takeIf { it > 0 } ?: return null+ synchronized(episodeIds) { episodeIds[identity] = id }+ return id+ }++ private suspend fun resolveShowTraktId(accessToken: String, showTmdbId: Long): Long? {+ val results = gson.fromJson(request("search/tmdb/$showTmdbId?type=show", accessToken), JsonArray::class.java)+ val matches = results.mapNotNull { element ->+ val result = element.asJsonObject+ val show = result.getAsJsonObject("show") ?: return@mapNotNull null+ val ids = show.getAsJsonObject("ids") ?: return@mapNotNull null+ if (result["type"]?.asString != "show" || ids["tmdb"]?.takeUnless { it.isJsonNull }?.asLong != showTmdbId) null+ else ids["trakt"]?.takeUnless { it.isJsonNull }?.asLong?.takeIf { it > 0 }+ }.distinct()+ return matches.singleOrNull()+ }++ private fun count(parent: JsonObject?, key: String): Int =+ parent?.get(key)?.takeUnless { it.isJsonNull }?.asInt?.coerceAtLeast(0) ?: 0++ private fun countArray(parent: JsonObject, key: String): Int =+ parent.getAsJsonArray(key)?.size() ?: 0++ private companion object {+ const val CUSTOM_LIST_PAGE_SIZE = 250+ const val DISCOVERY_PAGE_SIZE = 100+ const val SYNC_PAGE_SIZE = 100+ const val MAX_SYNC_PAGES = 50+ }++ override suspend fun exchange(code: String, verifier: String): TraktTokens = tokens(mapOf(+ "code" to code, "code_verifier" to verifier, "grant_type" to "authorization_code",+ "client_id" to config.clientId, "redirect_uri" to config.redirectUri,+ ))++ override suspend fun refresh(refreshToken: String): TraktTokens = tokens(mapOf(+ "refresh_token" to refreshToken, "grant_type" to "refresh_token",+ "client_id" to config.clientId, "redirect_uri" to config.redirectUri,+ ))++ private suspend fun tokens(payload: Map<String, String>): TraktTokens {+ val result = gson.fromJson(request("oauth/token", payload = payload), TraktTokens::class.java)+ require(!result.accessToken.isNullOrBlank() && !result.refreshToken.isNullOrBlank() &&+ result.expiresIn > 0 && result.createdAt > 0) { "Invalid Trakt token response" }+ return result+ }++ override suspend fun username(accessToken: String): String =+ gson.fromJson(request("users/settings", accessToken), JsonObject::class.java)+ .getAsJsonObject("user").get("username").asString++ override suspend fun profile(accessToken: String): TraktUserProfile {+ val user = gson.fromJson(request("users/settings", accessToken), JsonObject::class.java)+ .getAsJsonObject("user") ?: error("Missing Trakt user")+ fun string(name: String): String? = user.get(name)?.takeUnless { it.isJsonNull }+ ?.asString?.trim()?.takeIf { it.isNotEmpty() }+ return TraktUserProfile(+ username = string("username") ?: error("Missing Trakt username"),+ name = string("name"),+ location = string("location"),+ about = string("about"),+ gender = string("gender"),+ age = user.get("age")?.takeUnless { it.isJsonNull }?.let { runCatching { it.asInt }.getOrNull() }+ ?.takeIf { it in 1..120 },+ joinedAt = string("joined_at"),+ vip = user.get("vip")?.takeUnless { it.isJsonNull }?.let { runCatching { it.asBoolean }.getOrNull() } ?: false,+ )+ }++ private suspend fun request(path: String, token: String? = null, payload: Map<String, Any>? = null,+ observeHeaders: ((okhttp3.Headers) -> Unit)? = null,+ httpMethod: String = if (payload == null) "GET" else "POST"): String =+ withContext(Dispatchers.IO) {+ requestMutex.withLock {+ val now = System.currentTimeMillis()+ if (now < nextRequestAt) throw TraktApiException(429, retryAfterSeconds = (nextRequestAt - now + 999) / 1000)+ require(httpMethod in setOf("GET", "POST", "DELETE"))+ if (httpMethod != "GET") {+ delay((lastWriteAt + 1000 - now).coerceAtLeast(0))+ lastWriteAt = System.currentTimeMillis()+ }+ val builder = Request.Builder().url(baseUrl.resolve(path)!!)+ .header("trakt-api-key", config.clientId).header("trakt-api-version", "2")+ .header("Accept", "application/json")+ .header("Content-Type", "application/json")+ .header("User-Agent", userAgent)+ token?.let { builder.header("Authorization", "Bearer $it") }+ when (httpMethod) {+ "GET" -> Unit // Request.Builder defaults to GET.+ "POST" -> builder.post(gson.toJson(payload.orEmpty()).toRequestBody("application/json".toMediaType()))+ "DELETE" -> builder.delete()+ }+ client.newCall(builder.build()).execute().use { response ->+ val body = response.body?.string().orEmpty()+ if (!response.isSuccessful) {+ // Only retain the OAuth error identifier. Bodies can contain sensitive data.+ val error = runCatching { gson.fromJson(body, JsonObject::class.java)?.get("error")?.asString }.getOrNull()+ val retry = retryAfter(response.header("Retry-After"))+ if (response.code == 429) {+ rateLimitFailures = (rateLimitFailures + 1).coerceAtMost(6)+ val waitSeconds = retry ?: ((1L shl rateLimitFailures) + kotlin.random.Random.nextLong(1, 4))+ nextRequestAt = System.currentTimeMillis() + waitSeconds.coerceAtMost(31536000) * 1000+ }+ throw TraktApiException(response.code, error, retry)+ }+ rateLimitFailures = 0+ observeHeaders?.invoke(response.headers)+ body+ }+ }+ }++ private fun retryAfter(value: String?): Long? = value?.toLongOrNull()?.coerceAtLeast(0)+ ?: runCatching {+ (ZonedDateTime.parse(value, DateTimeFormatter.RFC_1123_DATE_TIME).toEpochSecond() -+ System.currentTimeMillis() / 1000).coerceAtLeast(0)+ }.getOrNull()++}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktAuthService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktAuthService.ktnew file mode 100644index 00000000..df1bde9a--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktAuthService.kt@@ -0,0 +1,751 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktMessage+import com.streamvault.domain.trakt.TraktScrobbler+import com.streamvault.domain.trakt.TraktScrobbleEvent+import com.streamvault.domain.trakt.TraktScrobbleAction+import com.streamvault.domain.trakt.TraktScrobbleOutcome+import com.streamvault.domain.trakt.TraktHistorySource+import com.streamvault.domain.trakt.TraktHistoryResult+import com.streamvault.domain.trakt.TraktHistoryUpload+import com.streamvault.domain.trakt.TraktHistoryUploadResult+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistPageResult+import com.streamvault.domain.trakt.TraktWatchlistSource+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktWatchlistWriteResult+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoritePage+import com.streamvault.domain.trakt.TraktFavoritePageResult+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavoritesSource+import com.streamvault.domain.trakt.TraktFavoriteWriteResult+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingPageResult+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktRatingsSource+import com.streamvault.domain.trakt.TraktRatingWriteResult+import com.streamvault.domain.trakt.TraktCustomListItemIdentity+import com.streamvault.domain.trakt.TraktCustomListItemType+import com.streamvault.domain.trakt.TraktCustomListItemsPageResult+import com.streamvault.domain.trakt.TraktCustomListsPageResult+import com.streamvault.domain.trakt.TraktCustomListsSource+import com.streamvault.domain.trakt.TraktCustomListWriteResult+import com.streamvault.domain.trakt.TraktDiscoveryCategory+import com.streamvault.domain.trakt.TraktDiscoveryPage+import com.streamvault.domain.trakt.TraktDiscoverySource+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import java.net.URI+import java.net.URLDecoder+import java.net.URLEncoder+import java.security.MessageDigest++class TraktAuthService(+ private val config: TraktConfig,+ private val store: TraktTokenStore,+ private val api: TraktApi,+ private val now: () -> Long = { System.currentTimeMillis() / 1000 },+) : TraktAccount, TraktScrobbler, TraktHistorySource, TraktWatchlistSource, TraktFavoritesSource,+ TraktRatingsSource, TraktCustomListsSource, TraktDiscoverySource {+ private val mutex = Mutex()+ private val mutableState = MutableStateFlow(TraktAccountState(configured = config.configured))+ override val state = mutableState.asStateFlow()++ override suspend fun load(): Unit = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ val session = store.read()+ mutableState.value = TraktAccountState(config.configured, session.tokens != null,+ connecting = session.pending?.let { now() - it.createdAt in 0..600 } == true)+ if (session.tokens != null) updateProfile()+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ mutableState.value = TraktAccountState(config.configured, message = TraktMessage.RECONNECT_REQUIRED)+ }+ }+ }++ override suspend fun beginSignIn(): String = withContext(Dispatchers.IO) {+ mutex.withLock {+ check(config.configured) { "Trakt configuration required" }+ val pending = TraktPendingLogin(TraktPkce.randomValue(), TraktPkce.randomValue(), now())+ store.write(TraktStoredSession(pending = pending))+ mutableState.value = TraktAccountState(configured = true, connecting = true)+ val parameters = linkedMapOf(+ "client_id" to config.clientId, "redirect_uri" to config.redirectUri,+ "response_type" to "code", "state" to pending.state,+ "code_challenge" to TraktPkce.challenge(pending.verifier), "code_challenge_method" to "S256",+ )+ "https://auth.trakt.tv/oauth/authorize?" + parameters.entries.joinToString("&") {+ "${encode(it.key)}=${encode(it.value)}"+ }+ }+ }++ override suspend fun completeSignIn(callback: String): Unit = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ check(config.configured)+ val pending = store.read().pending ?: return@withLock+ // Consume once before network I/O, including rejected and cancelled callbacks.+ store.write(TraktStoredSession())+ val actual = URI(callback)+ val expected = URI(config.redirectUri)+ require(actual.scheme == expected.scheme && actual.rawAuthority == expected.rawAuthority &&+ actual.rawPath == expected.rawPath && actual.rawFragment == null)+ val parameters = actual.rawQuery.orEmpty().split('&').filter(String::isNotEmpty).map {+ val pair = it.split('=', limit = 2)+ decode(pair[0]) to decode(pair.getOrElse(1) { "" })+ }+ require(parameters.map { it.first }.distinct().size == parameters.size)+ val values = parameters.toMap()+ require(now() - pending.createdAt in 0..600)+ require(MessageDigest.isEqual(pending.state.toByteArray(), values["state"].orEmpty().toByteArray()))+ if (values["error"] == "access_denied") {+ mutableState.value = TraktAccountState(configured = true)+ return@withLock+ }+ require(values["error"] == null)+ val code = values["code"]?.takeIf(String::isNotBlank) ?: error("Missing authorization code")+ val tokens = api.exchange(code, pending.verifier)+ store.write(TraktStoredSession(tokens))+ mutableState.value = TraktAccountState(configured = true, connected = true)+ updateProfile()+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ mutableState.value = TraktAccountState(config.configured, message = message(failure, TraktMessage.SIGN_IN_FAILED))+ }+ }+ }++ override suspend fun cancelSignIn(): Unit = withContext(Dispatchers.IO) {+ mutex.withLock {+ val session = store.read()+ store.write(TraktStoredSession(session.tokens))+ mutableState.value = mutableState.value.copy(connecting = false)+ }+ }++ override suspend fun disconnect(): Unit = withContext(Dispatchers.IO) {+ mutex.withLock {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured)+ }+ }++ override suspend fun refreshProfile(): Unit = withContext(Dispatchers.IO) {+ mutex.withLock { updateProfile() }+ }++ override suspend fun history(page: Int): TraktHistoryResult = withContext(Dispatchers.IO) {+ require(page in 1..10000)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktHistoryResult.Disconnected+ val historyApi = api as? TraktHistoryApi+ ?: return@withLock TraktHistoryResult.Failure(TraktMessage.NETWORK_ERROR)+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val result = try {+ historyApi.history(tokens.accessToken, page)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ historyApi.history(tokens.accessToken, page)+ }+ TraktHistoryResult.Success(result)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured, message = TraktMessage.RECONNECT_REQUIRED)+ }+ TraktHistoryResult.Failure(if (mutableState.value.message == TraktMessage.RECONNECT_REQUIRED)+ TraktMessage.RECONNECT_REQUIRED else message(failure, TraktMessage.NETWORK_ERROR))+ }+ }+ }++ override suspend fun upload(accountUsername: String,+ events: List<TraktHistoryUpload>): TraktHistoryUploadResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ val accountState = mutableState.value+ if (!accountState.connected || accountState.username != accountUsername) {+ return@withLock TraktHistoryUploadResult.Disconnected+ }+ var tokens = store.read().tokens ?: return@withLock TraktHistoryUploadResult.Disconnected+ val historyApi = api as? TraktHistoryApi ?: return@withLock TraktHistoryUploadResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ historyApi.upload(tokens.accessToken, events)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ historyApi.upload(tokens.accessToken, events)+ }+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured, message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktHistoryUploadResult.Disconnected+ }+ TraktHistoryUploadResult.Failed+ }+ }+ }++ override suspend fun watchlist(type: TraktWatchlistType, page: Int): TraktWatchlistPageResult =+ withContext(Dispatchers.IO) {+ require(page in 1..10000)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktWatchlistPageResult.Disconnected+ val watchlistApi = api as? TraktWatchlistApi+ ?: return@withLock TraktWatchlistPageResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val result = try {+ watchlistApi.watchlist(tokens.accessToken, type, page)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ watchlistApi.watchlist(tokens.accessToken, type, page)+ }+ TraktWatchlistPageResult.Success(result)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktWatchlistPageResult.Disconnected+ }+ TraktWatchlistPageResult.Failed+ }+ }+ }++ override suspend fun discover(category: TraktDiscoveryCategory, page: Int): TraktDiscoveryPage {+ val discoveryApi = api as? TraktDiscoveryApi ?: error("Trakt discovery API is unavailable")+ return discoveryApi.discover(category, page)+ }++ override suspend fun setWatchlisted(+ identity: TraktWatchlistIdentity,+ watchlisted: Boolean,+ ): TraktWatchlistWriteResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktWatchlistWriteResult.Disconnected+ val watchlistApi = api as? TraktWatchlistApi+ ?: return@withLock TraktWatchlistWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ watchlistApi.setWatchlisted(tokens.accessToken, identity, watchlisted)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ watchlistApi.setWatchlisted(tokens.accessToken, identity, watchlisted)+ }+ TraktWatchlistWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktWatchlistWriteResult.Disconnected+ }+ // A write can succeed before a timeout. Do not retry it automatically.+ TraktWatchlistWriteResult.Failed+ }+ }+ }++ override suspend fun setFavorited(+ identity: TraktFavoriteIdentity,+ favorited: Boolean,+ ): TraktFavoriteWriteResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktFavoriteWriteResult.Disconnected+ val favoritesApi = api as? TraktFavoritesApi ?: return@withLock TraktFavoriteWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ favoritesApi.setFavorited(tokens.accessToken, identity, favorited)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ favoritesApi.setFavorited(tokens.accessToken, identity, favorited)+ }+ TraktFavoriteWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktFavoriteWriteResult.Disconnected+ }+ // Do not automatically retry a request that might have succeeded before a timeout.+ TraktFavoriteWriteResult.Failed+ }+ }+ }++ override suspend fun favorites(type: TraktFavoriteType, page: Int): TraktFavoritePageResult =+ withContext(Dispatchers.IO) {+ require(page in 1..10000)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktFavoritePageResult.Disconnected+ val favoritesApi = api as? TraktFavoritesApi ?: return@withLock TraktFavoritePageResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val result = try {+ favoritesApi.favorites(tokens.accessToken, type, page)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ favoritesApi.favorites(tokens.accessToken, type, page)+ }+ TraktFavoritePageResult.Success(result)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktFavoritePageResult.Disconnected+ }+ TraktFavoritePageResult.Failed+ }+ }+ }++ override suspend fun setRating(+ identity: TraktRatingIdentity,+ rating: Int,+ ): TraktRatingWriteResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ require(rating in 1..10)+ var tokens = store.read().tokens ?: return@withLock TraktRatingWriteResult.Disconnected+ val ratingsApi = api as? TraktRatingsApi ?: return@withLock TraktRatingWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ ratingsApi.setRating(tokens.accessToken, identity, rating)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ ratingsApi.setRating(tokens.accessToken, identity, rating)+ }+ TraktRatingWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktRatingWriteResult.Disconnected+ }+ // A write can succeed before a timeout. Do not retry it automatically.+ TraktRatingWriteResult.Failed+ }+ }+ }++ override suspend fun ratings(type: TraktRatingType, page: Int): TraktRatingPageResult =+ withContext(Dispatchers.IO) {+ require(page in 1..10000)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktRatingPageResult.Disconnected+ val ratingsApi = api as? TraktRatingsApi ?: return@withLock TraktRatingPageResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val result = try {+ ratingsApi.ratings(tokens.accessToken, type, page)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ ratingsApi.ratings(tokens.accessToken, type, page)+ }+ TraktRatingPageResult.Success(result)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktRatingPageResult.Disconnected+ }+ TraktRatingPageResult.Failed+ }+ }+ }++ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktScrobbleOutcome.DISCONNECTED+ val playback = api as? TraktPlaybackApi ?: return@withLock TraktScrobbleOutcome.FAILED+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val matched = try {+ playback.scrobble(tokens.accessToken, event)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ playback.scrobble(tokens.accessToken, event)+ }+ if (matched) TraktScrobbleOutcome.SENT else TraktScrobbleOutcome.UNMATCHED+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 409 && event.action == TraktScrobbleAction.STOP) {+ return@withLock TraktScrobbleOutcome.DUPLICATE+ }+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured, message = TraktMessage.RECONNECT_REQUIRED)+ }+ // Never retry a possibly accepted write after timeout, 429, or a transport failure.+ TraktScrobbleOutcome.FAILED+ }+ }+ }++ override suspend fun lists(): TraktCustomListsPageResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktCustomListsPageResult.Disconnected+ val listsApi = api as? TraktCustomListsApi ?: return@withLock TraktCustomListsPageResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val result = try {+ listsApi.lists(tokens.accessToken)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ listsApi.lists(tokens.accessToken)+ }+ TraktCustomListsPageResult.Success(result)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktCustomListsPageResult.Disconnected+ }+ TraktCustomListsPageResult.Failed+ }+ }+ }++ override suspend fun items(+ listId: Long,+ type: TraktCustomListItemType,+ page: Int,+ ): TraktCustomListItemsPageResult = withContext(Dispatchers.IO) {+ require(listId > 0L && page in 1..10000)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktCustomListItemsPageResult.Disconnected+ val listsApi = api as? TraktCustomListsApi ?: return@withLock TraktCustomListItemsPageResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val result = try {+ listsApi.items(tokens.accessToken, listId, type, page)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ listsApi.items(tokens.accessToken, listId, type, page)+ }+ TraktCustomListItemsPageResult.Success(result)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktCustomListItemsPageResult.Disconnected+ }+ TraktCustomListItemsPageResult.Failed+ }+ }+ }++ override suspend fun createList(name: String, description: String?): TraktCustomListWriteResult =+ withContext(Dispatchers.IO) {+ require(name.isNotBlank())+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktCustomListWriteResult.Disconnected+ val listsApi = api as? TraktCustomListsApi ?: return@withLock TraktCustomListWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ listsApi.createList(tokens.accessToken, name, description)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ listsApi.createList(tokens.accessToken, name, description)+ }+ TraktCustomListWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktCustomListWriteResult.Disconnected+ }+ // Creation is a write and is not retried after an ambiguous transport failure.+ TraktCustomListWriteResult.Failed+ }+ }+ }++ override suspend fun deleteList(listId: Long): TraktCustomListWriteResult = withContext(Dispatchers.IO) {+ require(listId > 0L)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktCustomListWriteResult.Disconnected+ val listsApi = api as? TraktCustomListsApi ?: return@withLock TraktCustomListWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ listsApi.deleteList(tokens.accessToken, listId)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ listsApi.deleteList(tokens.accessToken, listId)+ }+ TraktCustomListWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktCustomListWriteResult.Disconnected+ }+ // A deletion may have reached Trakt before a transport failure, so do not retry it.+ TraktCustomListWriteResult.Failed+ }+ }+ }++ override suspend fun reorderLists(listIds: List<Long>): TraktCustomListWriteResult = withContext(Dispatchers.IO) {+ require(listIds.isNotEmpty() && listIds.all { it > 0L } && listIds.distinct().size == listIds.size)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktCustomListWriteResult.Disconnected+ val listsApi = api as? TraktCustomListsApi ?: return@withLock TraktCustomListWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ listsApi.reorderLists(tokens.accessToken, listIds)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ listsApi.reorderLists(tokens.accessToken, listIds)+ }+ TraktCustomListWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktCustomListWriteResult.Disconnected+ }+ // Reordering is a write and may have succeeded before a transport failure.+ TraktCustomListWriteResult.Failed+ }+ }+ }++ override suspend fun reorderItems(listId: Long, listItemIds: List<Long>): TraktCustomListWriteResult = withContext(Dispatchers.IO) {+ require(listId > 0L && listItemIds.isNotEmpty() && listItemIds.all { it > 0L } &&+ listItemIds.distinct().size == listItemIds.size)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktCustomListWriteResult.Disconnected+ val listsApi = api as? TraktCustomListsApi ?: return@withLock TraktCustomListWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ listsApi.reorderItems(tokens.accessToken, listId, listItemIds)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ listsApi.reorderItems(tokens.accessToken, listId, listItemIds)+ }+ TraktCustomListWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktCustomListWriteResult.Disconnected+ }+ // A reorder can reach Trakt before a transport failure; never retry it automatically.+ TraktCustomListWriteResult.Failed+ }+ }+ }++ override suspend fun setItem(+ listId: Long,+ identity: TraktCustomListItemIdentity,+ included: Boolean,+ ): TraktCustomListWriteResult = withContext(Dispatchers.IO) {+ require(listId > 0L)+ mutex.withLock {+ try {+ var tokens = store.read().tokens ?: return@withLock TraktCustomListWriteResult.Disconnected+ val listsApi = api as? TraktCustomListsApi ?: return@withLock TraktCustomListWriteResult.Failed+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ try {+ listsApi.setItem(tokens.accessToken, listId, identity, included)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ listsApi.setItem(tokens.accessToken, listId, identity, included)+ }+ TraktCustomListWriteResult.Success+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured,+ message = TraktMessage.RECONNECT_REQUIRED)+ return@withLock TraktCustomListWriteResult.Disconnected+ }+ // A write can succeed before a timeout. Never retry it automatically.+ TraktCustomListWriteResult.Failed+ }+ }+ }++ /** All authenticated operations share this lock; a rotating token is consumed exactly once. */+ private suspend fun refresh(tokens: TraktTokens): TraktTokens {+ // Persist consumption BEFORE calling Trakt. A crash or ambiguous network result must not+ // reuse a single-use refresh token on the next launch. Reconnection is safer than reuse.+ store.write(TraktStoredSession())+ return try {+ api.refresh(tokens.refreshToken).also { store.write(TraktStoredSession(it)) }+ } catch (failure: Exception) {+ if (failure is TraktApiException && failure.status == 429) {+ // An explicit rate-limit rejection issued no new token. Keep the session so+ // the user can retry after the client's cooldown rather than sign in again.+ store.write(TraktStoredSession(tokens))+ mutableState.value = mutableState.value.copy(connected = true, message = TraktMessage.RATE_LIMITED)+ throw failure+ }+ mutableState.value = TraktAccountState(config.configured, message = TraktMessage.RECONNECT_REQUIRED)+ throw failure+ }+ }++ private suspend fun updateProfile() {+ try {+ var tokens = store.read().tokens ?: return+ var refreshed = false+ if (!tokens.usable(now())) {+ tokens = refresh(tokens)+ refreshed = true+ }+ val profile = try {+ api.profile(tokens.accessToken)+ } catch (failure: TraktApiException) {+ if (failure.status != 401 || refreshed) throw failure+ tokens = refresh(tokens)+ api.profile(tokens.accessToken)+ }+ require(profile.username.isNotBlank()) { "Missing Trakt username" }+ mutableState.value = TraktAccountState(config.configured, connected = true,+ username = profile.username, profile = profile)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ if (failure is TraktApiException && failure.status == 401) {+ store.write(TraktStoredSession())+ mutableState.value = TraktAccountState(config.configured, message = TraktMessage.RECONNECT_REQUIRED)+ } else if (mutableState.value.message != TraktMessage.RECONNECT_REQUIRED) {+ mutableState.value = mutableState.value.copy(message = message(failure, TraktMessage.NETWORK_ERROR))+ }+ }+ }++ private fun message(failure: Exception, fallback: TraktMessage) =+ if (failure is TraktApiException && failure.status == 429) TraktMessage.RATE_LIMITED else fallback++ private fun encode(value: String) = URLEncoder.encode(value, "UTF-8")+ private fun decode(value: String) = URLDecoder.decode(value, "UTF-8")+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktCustomListsService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktCustomListsService.ktnew file mode 100644index 00000000..17e9a17a--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktCustomListsService.kt@@ -0,0 +1,459 @@+package com.streamvault.data.trakt++import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktCustomList+import com.streamvault.domain.trakt.TraktCustomListActionResult+import com.streamvault.domain.trakt.TraktCustomListItemIdentity+import com.streamvault.domain.trakt.TraktCustomListItem+import com.streamvault.domain.trakt.TraktCustomListItemType+import com.streamvault.domain.trakt.TraktCustomListItemsPageResult+import com.streamvault.domain.trakt.TraktCustomListItemsRefreshResult+import com.streamvault.domain.trakt.TraktCustomListRefreshResult+import com.streamvault.domain.trakt.TraktCustomListWriteResult+import com.streamvault.domain.trakt.TraktCustomLists+import com.streamvault.domain.trakt.TraktCustomListsFailure+import com.streamvault.domain.trakt.TraktCustomListsPageResult+import com.streamvault.domain.trakt.TraktCustomListsSource+import com.streamvault.domain.trakt.TraktCustomListsState+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import javax.inject.Inject+import javax.inject.Singleton++/** Loads personal-list metadata and contents only when the user opens them. */+@Singleton+class TraktCustomListsService @Inject constructor(+ private val account: TraktAccount,+ private val source: TraktCustomListsSource,+ private val history: PlaybackHistoryRepository,+) : TraktCustomLists {+ private val mutex = Mutex()+ private val mutableState = MutableStateFlow(TraktCustomListsState())+ override val state = mutableState.asStateFlow()++ override suspend fun refreshLists(force: Boolean): TraktCustomListRefreshResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock listsFailure(TraktCustomListsFailure.INCOGNITO)+ if (!account.state.value.connected) account.load()+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock listsFailure(TraktCustomListsFailure.DISCONNECTED)+ fun sameAccount() = account.state.value.connected && account.state.value.username == owner++ val current = mutableState.value+ if (current.accountUsername != owner) {+ mutableState.value = TraktCustomListsState(accountUsername = owner, connected = true)+ } else if (!force && current.listsLoadedAtMs?.let {+ System.currentTimeMillis() - it < CACHE_TTL_MS+ } == true+ ) {+ mutableState.value = current.copy(connected = true, failure = null)+ return@withLock TraktCustomListRefreshResult.Success(current.lists.size)+ }++ mutableState.value = mutableState.value.copy(+ accountUsername = owner,+ connected = true,+ refreshingLists = true,+ failure = null,+ )+ val result = when (val response = source.lists()) {+ is TraktCustomListsPageResult.Success -> response.lists+ TraktCustomListsPageResult.Disconnected ->+ return@withLock listsFailure(TraktCustomListsFailure.DISCONNECTED)+ TraktCustomListsPageResult.Failed ->+ return@withLock listsFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ if (!sameAccount()) return@withLock listsFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ if (history.isIncognitoModeEnabled()) return@withLock listsFailure(TraktCustomListsFailure.INCOGNITO)+ if (result.any { it.id <= 0L || it.name.isBlank() || it.itemCount < 0 } ||+ result.map { it.id }.distinct().size != result.size+ ) return@withLock listsFailure(TraktCustomListsFailure.REQUEST_FAILED)++ val previous = mutableState.value+ val validIds = result.mapTo(hashSetOf()) { it.id }+ mutableState.value = TraktCustomListsState(+ accountUsername = owner,+ connected = true,+ lists = result,+ listsLoadedAtMs = System.currentTimeMillis(),+ itemsByList = previous.itemsByList.filterKeys { it in validIds },+ itemsLoadedAtMs = previous.itemsLoadedAtMs.filterKeys { it in validIds },+ )+ TraktCustomListRefreshResult.Success(result.size)+ } catch (failure: Exception) {+ if (failure is CancellationException) {+ mutableState.value = mutableState.value.copy(refreshingLists = false)+ throw failure+ }+ listsFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ }+ }++ override suspend fun refreshItems(+ listId: Long,+ force: Boolean,+ ): TraktCustomListItemsRefreshResult {+ require(listId > 0L)+ val current = mutableState.value+ if (!current.listsLoaded || current.accountUsername != account.state.value.username ||+ current.listsLoadedAtMs?.let { System.currentTimeMillis() - it >= CACHE_TTL_MS } != false+ ) {+ when (val refreshed = refreshLists()) {+ is TraktCustomListRefreshResult.Failure ->+ return TraktCustomListItemsRefreshResult.Failure(refreshed.reason)+ is TraktCustomListRefreshResult.Success -> Unit+ }+ }++ return withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock itemsFailure(TraktCustomListsFailure.INCOGNITO, listId)+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock itemsFailure(TraktCustomListsFailure.DISCONNECTED, listId)+ val currentState = mutableState.value+ if (currentState.accountUsername != owner || currentState.list(listId) == null) {+ return@withLock itemsFailure(TraktCustomListsFailure.ACCOUNT_CHANGED, listId)+ }+ if (!force && currentState.itemsLoadedAtMs[listId]?.let {+ System.currentTimeMillis() - it < CACHE_TTL_MS+ } == true+ ) return@withLock TraktCustomListItemsRefreshResult.Success(+ currentState.itemsByList[listId].orEmpty().size,+ )++ fun sameAccount() = account.state.value.connected && account.state.value.username == owner+ mutableState.value = currentState.copy(+ loadingItems = currentState.loadingItems + listId,+ failure = null,+ )+ val staged = linkedMapOf<TraktCustomListItemIdentity, com.streamvault.domain.trakt.TraktCustomListItem>()+ var skipped = 0+ for (type in TraktCustomListItemType.entries) {+ var finished = false+ for (page in 1..MAX_PAGES) {+ if (!sameAccount()) return@withLock itemsFailure(TraktCustomListsFailure.ACCOUNT_CHANGED, listId)+ if (history.isIncognitoModeEnabled()) return@withLock itemsFailure(TraktCustomListsFailure.INCOGNITO, listId)+ when (val response = source.items(listId, type, page)) {+ is TraktCustomListItemsPageResult.Success -> {+ val data = response.page+ if (data.page != page || data.items.size > PAGE_SIZE ||+ data.items.any { it.identity.type != type || it.title.isBlank() }+ ) return@withLock itemsFailure(TraktCustomListsFailure.REQUEST_FAILED, listId)+ data.items.forEach { staged.putIfAbsent(it.identity, it) }+ skipped += data.skippedItems+ if (!data.hasMore) {+ finished = true+ break+ }+ if (page == MAX_PAGES) return@withLock itemsFailure(TraktCustomListsFailure.READ_LIMIT, listId)+ }+ TraktCustomListItemsPageResult.Disconnected ->+ return@withLock itemsFailure(TraktCustomListsFailure.DISCONNECTED, listId)+ TraktCustomListItemsPageResult.Failed ->+ return@withLock itemsFailure(TraktCustomListsFailure.REQUEST_FAILED, listId)+ }+ }+ if (!finished) return@withLock itemsFailure(TraktCustomListsFailure.READ_LIMIT, listId)+ }+ if (!sameAccount()) return@withLock itemsFailure(TraktCustomListsFailure.ACCOUNT_CHANGED, listId)+ if (history.isIncognitoModeEnabled()) return@withLock itemsFailure(TraktCustomListsFailure.INCOGNITO, listId)+ val latest = mutableState.value+ if (latest.accountUsername != owner || latest.list(listId) == null) {+ return@withLock itemsFailure(TraktCustomListsFailure.ACCOUNT_CHANGED, listId)+ }+ mutableState.value = latest.copy(+ itemsByList = latest.itemsByList + (listId to staged.values.sortedWith(+ compareBy<com.streamvault.domain.trakt.TraktCustomListItem> { it.rank ?: Int.MAX_VALUE }+ .thenBy { it.title.lowercase() },+ )),+ itemsLoadedAtMs = latest.itemsLoadedAtMs + (listId to System.currentTimeMillis()),+ loadingItems = latest.loadingItems - listId,+ failure = null,+ )+ TraktCustomListItemsRefreshResult.Success(staged.size, skipped)+ } catch (failure: Exception) {+ if (failure is CancellationException) {+ mutableState.value = mutableState.value.copy(loadingItems = mutableState.value.loadingItems - listId)+ throw failure+ }+ itemsFailure(TraktCustomListsFailure.REQUEST_FAILED, listId)+ }+ }+ }+ }++ override suspend fun createList(name: String, description: String?): TraktCustomListActionResult {+ val normalizedName = name.trim()+ if (normalizedName.isEmpty()) return TraktCustomListActionResult.Failure(TraktCustomListsFailure.REQUEST_FAILED)+ val result = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ if (!account.state.value.connected) account.load()+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock actionFailure(TraktCustomListsFailure.DISCONNECTED)+ when (source.createList(normalizedName, description?.trim()?.takeIf { it.isNotEmpty() })) {+ TraktCustomListWriteResult.Success -> {+ if (!account.state.value.connected || account.state.value.username != owner) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ mutableState.value = mutableState.value.copy(listsLoadedAtMs = null, failure = null)+ TraktCustomListActionResult.Success+ }+ TraktCustomListWriteResult.Disconnected -> actionFailure(TraktCustomListsFailure.DISCONNECTED)+ TraktCustomListWriteResult.Failed -> actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ }+ }+ if (result == TraktCustomListActionResult.Success) refreshLists(force = true)+ return result+ }++ override suspend fun deleteList(listId: Long): TraktCustomListActionResult =+ mutateLists(deleteId = listId)++ override suspend fun reorderLists(listIds: List<Long>): TraktCustomListActionResult =+ mutateLists(orderedIds = listIds)++ private suspend fun mutateLists(+ deleteId: Long? = null,+ orderedIds: List<Long>? = null,+ ): TraktCustomListActionResult {+ require((deleteId != null) xor (orderedIds != null))+ if (deleteId != null) require(deleteId > 0L)+ if (orderedIds != null) require(orderedIds.isNotEmpty() && orderedIds.all { it > 0L } &&+ orderedIds.distinct().size == orderedIds.size)++ if (!mutableState.value.listsLoaded) {+ when (val loaded = refreshLists(force = true)) {+ is TraktCustomListRefreshResult.Failure -> return TraktCustomListActionResult.Failure(loaded.reason)+ is TraktCustomListRefreshResult.Success -> Unit+ }+ }+ return withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock actionFailure(TraktCustomListsFailure.DISCONNECTED)+ val current = mutableState.value+ if (current.accountUsername != owner || !current.listsLoaded) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ val currentIds = current.lists.map { it.id }+ if (deleteId != null && deleteId !in currentIds) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ if (orderedIds != null && (orderedIds.size != currentIds.size || orderedIds.toSet() != currentIds.toSet())) {+ return@withLock actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ val response = if (deleteId != null) source.deleteList(deleteId)+ else source.reorderLists(requireNotNull(orderedIds))+ when (response) {+ TraktCustomListWriteResult.Disconnected -> actionFailure(TraktCustomListsFailure.DISCONNECTED)+ TraktCustomListWriteResult.Failed -> actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ TraktCustomListWriteResult.Success -> {+ if (!account.state.value.connected || account.state.value.username != owner) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ val latest = mutableState.value+ val nextLists = if (deleteId != null) {+ latest.lists.filterNot { it.id == deleteId }+ } else {+ val byId = latest.lists.associateBy { it.id }+ requireNotNull(orderedIds).map { byId.getValue(it) }+ }+ mutableState.value = latest.copy(+ lists = nextLists,+ listsLoadedAtMs = System.currentTimeMillis(),+ itemsByList = if (deleteId == null) latest.itemsByList else latest.itemsByList - deleteId,+ itemsLoadedAtMs = if (deleteId == null) latest.itemsLoadedAtMs else latest.itemsLoadedAtMs - deleteId,+ failure = null,+ )+ TraktCustomListActionResult.Success+ }+ }+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ }+ }+ }++ override suspend fun reorderItems(+ listId: Long,+ items: List<com.streamvault.domain.trakt.TraktCustomListItem>,+ ): TraktCustomListActionResult {+ require(listId > 0L)+ if (!mutableState.value.itemsLoaded(listId)) {+ when (val loaded = refreshItems(listId, force = true)) {+ is TraktCustomListItemsRefreshResult.Failure -> return TraktCustomListActionResult.Failure(loaded.reason)+ is TraktCustomListItemsRefreshResult.Success -> Unit+ }+ }+ return withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock actionFailure(TraktCustomListsFailure.DISCONNECTED)+ val current = mutableState.value+ if (current.accountUsername != owner || current.list(listId) == null || !current.itemsLoaded(listId)) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ val currentItems = current.itemsByList[listId].orEmpty()+ val requestedIds = items.mapNotNull { it.listItemId }+ val currentIds = currentItems.mapNotNull { it.listItemId }+ if (items.size != currentItems.size || items.map { it.identity }.toSet() != currentItems.map { it.identity }.toSet() ||+ requestedIds.size != items.size || requestedIds.distinct().size != requestedIds.size ||+ currentIds.size != currentItems.size || currentIds.toSet() != requestedIds.toSet()+ ) return@withLock actionFailure(TraktCustomListsFailure.REQUEST_FAILED)++ when (source.reorderItems(listId, requestedIds)) {+ TraktCustomListWriteResult.Disconnected -> actionFailure(TraktCustomListsFailure.DISCONNECTED)+ TraktCustomListWriteResult.Failed -> actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ TraktCustomListWriteResult.Success -> {+ if (!account.state.value.connected || account.state.value.username != owner) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ val latest = mutableState.value+ mutableState.value = latest.copy(+ itemsByList = latest.itemsByList + (listId to items.mapIndexed { index, item ->+ item.copy(rank = index + 1)+ }),+ itemsLoadedAtMs = latest.itemsLoadedAtMs + (listId to System.currentTimeMillis()),+ failure = null,+ )+ TraktCustomListActionResult.Success+ }+ }+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ }+ }+ }++ override suspend fun setItem(+ listId: Long,+ item: TraktCustomListItem,+ included: Boolean,+ ): TraktCustomListActionResult {+ require(listId > 0L)+ val result = withContext(Dispatchers.IO) {+ mutex.withLock {+ val identity = item.identity+ val key = listId to identity+ try {+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock actionFailure(TraktCustomListsFailure.DISCONNECTED)+ val current = mutableState.value+ if (current.accountUsername != owner || current.list(listId) == null) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ if (listId in current.loadingItems) return@withLock actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ val containsKnown = current.itemsLoaded(listId)+ val exists = current.contains(listId, identity)+ if (containsKnown && exists == included) return@withLock TraktCustomListActionResult.Success+ mutableState.value = current.copy(updatingItems = current.updatingItems + key, failure = null)+ when (source.setItem(listId, identity, included)) {+ TraktCustomListWriteResult.Success -> {+ if (!account.state.value.connected || account.state.value.username != owner) {+ return@withLock actionFailure(TraktCustomListsFailure.ACCOUNT_CHANGED)+ }+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktCustomListsFailure.INCOGNITO)+ val latest = mutableState.value+ val oldItems = latest.itemsByList[listId].orEmpty()+ val updatedItems = if (latest.itemsLoaded(listId)) {+ if (included) {+ oldItems.filterNot { it.identity == identity } + item+ } else oldItems.filterNot { it.identity == identity }+ } else oldItems+ // An unloaded list stays unloaded; a successful write is reflected in the+ // cached count only when its prior item snapshot was complete.+ val countDelta = if (latest.itemsLoaded(listId) && exists != included) {+ if (included) 1 else -1+ } else 0+ mutableState.value = latest.copy(+ lists = latest.lists.map { list ->+ if (list.id == listId) list.copy(itemCount = (list.itemCount + countDelta).coerceAtLeast(0)) else list+ },+ itemsByList = latest.itemsByList + (listId to updatedItems),+ updatingItems = latest.updatingItems - key,+ failure = null,+ )+ TraktCustomListActionResult.Success+ }+ TraktCustomListWriteResult.Disconnected -> actionFailure(TraktCustomListsFailure.DISCONNECTED)+ TraktCustomListWriteResult.Failed -> actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ }+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ actionFailure(TraktCustomListsFailure.REQUEST_FAILED)+ } finally {+ val latest = mutableState.value+ if (key in latest.updatingItems) {+ mutableState.value = latest.copy(updatingItems = latest.updatingItems - key)+ }+ }+ }+ }+ // Re-read a newly added entry so its stable Trakt list-item id is available for reordering.+ if (result == TraktCustomListActionResult.Success && included && mutableState.value.itemsLoaded(listId)) {+ refreshItems(listId, force = true)+ }+ return result+ }++ private fun listsFailure(reason: TraktCustomListsFailure): TraktCustomListRefreshResult.Failure {+ val clear = reason == TraktCustomListsFailure.DISCONNECTED || reason == TraktCustomListsFailure.INCOGNITO ||+ reason == TraktCustomListsFailure.ACCOUNT_CHANGED+ val current = mutableState.value+ mutableState.value = if (clear) TraktCustomListsState(connected = account.state.value.connected, failure = reason)+ else current.copy(refreshingLists = false, failure = reason)+ return TraktCustomListRefreshResult.Failure(reason)+ }++ private fun itemsFailure(reason: TraktCustomListsFailure, listId: Long): TraktCustomListItemsRefreshResult.Failure {+ val clear = reason == TraktCustomListsFailure.DISCONNECTED || reason == TraktCustomListsFailure.INCOGNITO ||+ reason == TraktCustomListsFailure.ACCOUNT_CHANGED+ val current = mutableState.value+ mutableState.value = if (clear) TraktCustomListsState(connected = account.state.value.connected, failure = reason)+ else current.copy(loadingItems = current.loadingItems - listId, failure = reason)+ return TraktCustomListItemsRefreshResult.Failure(reason)+ }++ private fun actionFailure(reason: TraktCustomListsFailure): TraktCustomListActionResult.Failure {+ val clear = reason == TraktCustomListsFailure.DISCONNECTED || reason == TraktCustomListsFailure.INCOGNITO ||+ reason == TraktCustomListsFailure.ACCOUNT_CHANGED+ val current = mutableState.value+ mutableState.value = if (clear) TraktCustomListsState(connected = account.state.value.connected, failure = reason)+ else current.copy(updatingItems = emptySet(), failure = reason)+ return TraktCustomListActionResult.Failure(reason)+ }++ private companion object {+ const val PAGE_SIZE = 250+ const val MAX_PAGES = 50+ const val CACHE_TTL_MS = 5 * 60 * 1000L+ }+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktDiscoveryService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktDiscoveryService.ktnew file mode 100644index 00000000..349dcafb--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktDiscoveryService.kt@@ -0,0 +1,72 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktDiscovery+import com.streamvault.domain.trakt.TraktDiscoveryCategory+import com.streamvault.domain.trakt.TraktDiscoveryRefreshResult+import com.streamvault.domain.trakt.TraktDiscoverySource+import com.streamvault.domain.trakt.TraktDiscoveryState+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import javax.inject.Inject+import javax.inject.Singleton++/** Caches the small public discovery pages StreamVault uses and deduplicates refreshes. */+@Singleton+class TraktDiscoveryService @Inject constructor(+ private val source: TraktDiscoverySource,+) : TraktDiscovery {+ private val mutex = Mutex()+ private val mutableState = MutableStateFlow(TraktDiscoveryState())+ override val state = mutableState.asStateFlow()++ override suspend fun refresh(+ category: TraktDiscoveryCategory,+ force: Boolean,+ ): TraktDiscoveryRefreshResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ val current = mutableState.value+ val loadedAt = current.loadedAtByCategory[category]+ if (!force && loadedAt != null && System.currentTimeMillis() - loadedAt < CACHE_TTL_MS) {+ mutableState.value = current.copy(failed = current.failed - category)+ return@withLock TraktDiscoveryRefreshResult.Success(current.items(category).size)+ }++ mutableState.value = current.copy(+ refreshing = current.refreshing + category,+ failed = current.failed - category,+ )+ try {+ val page = source.discover(category, page = 1)+ val items = page.tmdbIds.asSequence().filter { it > 0L }.distinct().take(PAGE_SIZE).toList()+ val latest = mutableState.value+ mutableState.value = latest.copy(+ itemsByCategory = latest.itemsByCategory + (category to items),+ loadedAtByCategory = latest.loadedAtByCategory + (category to System.currentTimeMillis()),+ refreshing = latest.refreshing - category,+ failed = latest.failed - category,+ )+ TraktDiscoveryRefreshResult.Success(items.size, page.skippedItems)+ } catch (failure: CancellationException) {+ mutableState.value = mutableState.value.copy(refreshing = mutableState.value.refreshing - category)+ throw failure+ } catch (_: Exception) {+ val latest = mutableState.value+ mutableState.value = latest.copy(+ refreshing = latest.refreshing - category,+ failed = latest.failed + category,+ )+ TraktDiscoveryRefreshResult.Failure+ }+ }+ }++ private companion object {+ const val PAGE_SIZE = 100+ const val CACHE_TTL_MS = 30 * 60 * 1000L+ }+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktFavoriteImporterService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktFavoriteImporterService.ktnew file mode 100644index 00000000..67a5fe34--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktFavoriteImporterService.kt@@ -0,0 +1,121 @@+package com.streamvault.data.trakt++import com.streamvault.domain.model.ContentType+import com.streamvault.domain.repository.FavoriteRepository+import com.streamvault.domain.repository.MovieRepository+import com.streamvault.domain.repository.ProviderRepository+import com.streamvault.domain.repository.SeriesRepository+import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteImportResult+import com.streamvault.domain.trakt.TraktFavoriteImporter+import com.streamvault.domain.trakt.TraktFavoritePageResult+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavoritesSource+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import javax.inject.Inject+import javax.inject.Singleton++/** Imports Trakt's existing movie/show hearts into local Favorites for the active provider. */+@Singleton+class TraktFavoriteImporterService @Inject constructor(+ private val account: TraktAccount,+ private val source: TraktFavoritesSource,+ private val history: PlaybackHistoryRepository,+ private val providers: ProviderRepository,+ private val movies: MovieRepository,+ private val series: SeriesRepository,+ private val favorites: FavoriteRepository,+) : TraktFavoriteImporter {+ private val mutex = Mutex()++ override suspend fun importToLocal(): TraktFavoriteImportResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ var imported = 0+ try {+ if (history.isIncognitoModeEnabled()) return@withLock fail(TraktFavoriteFailure.INCOGNITO)+ if (!account.state.value.connected) account.load()+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock fail(TraktFavoriteFailure.DISCONNECTED)+ val provider = providers.getActiveProvider().first()+ ?: return@withLock fail(TraktFavoriteFailure.NO_ACTIVE_PROVIDER)+ fun sameAccount() = account.state.value.connected && account.state.value.username == owner++ val staged = linkedSetOf<TraktFavoriteIdentity>()+ var skipped = 0+ for (type in TraktFavoriteType.entries) {+ var hasMore = true+ for (pageNumber in 1..MAX_PAGES) {+ if (!sameAccount()) return@withLock fail(TraktFavoriteFailure.ACCOUNT_CHANGED)+ if (history.isIncognitoModeEnabled()) return@withLock fail(TraktFavoriteFailure.INCOGNITO)+ val page = when (val result = source.favorites(type, pageNumber)) {+ is TraktFavoritePageResult.Success -> result.page+ TraktFavoritePageResult.Disconnected -> return@withLock fail(TraktFavoriteFailure.DISCONNECTED)+ TraktFavoritePageResult.Failed -> return@withLock fail(TraktFavoriteFailure.REQUEST_FAILED)+ }+ if (page.page != pageNumber || page.identities.any { it.type != type }) {+ return@withLock fail(TraktFavoriteFailure.REQUEST_FAILED)+ }+ staged += page.identities+ skipped += page.skippedItems+ hasMore = page.hasMore+ if (!hasMore) break+ if (pageNumber == MAX_PAGES) return@withLock fail(TraktFavoriteFailure.READ_LIMIT)+ }+ }++ if (!sameAccount()) return@withLock fail(TraktFavoriteFailure.ACCOUNT_CHANGED)+ if (history.isIncognitoModeEnabled()) return@withLock fail(TraktFavoriteFailure.INCOGNITO)+ val movieIds = staged.filter { it.type == TraktFavoriteType.MOVIE }.map { it.tmdbId }.distinct()+ val showIds = staged.filter { it.type == TraktFavoriteType.SHOW }.map { it.tmdbId }.distinct()+ val localMovies = movies.getMoviesByTmdbIds(provider.id, movieIds).filter { it.providerId == provider.id }+ val localShows = series.getSeriesByTmdbIds(provider.id, showIds).filter { it.providerId == provider.id }+ val moviesByTmdb = localMovies.filter { it.tmdbId != null }.groupBy { it.tmdbId!! }+ val showsByTmdb = localShows.filter { it.tmdbId != null }.groupBy { it.tmdbId!! }+ var alreadyPresent = 0+ var unmatched = 0+ for (identity in staged) {+ if (!sameAccount()) return@withLock fail(TraktFavoriteFailure.ACCOUNT_CHANGED, imported)+ if (history.isIncognitoModeEnabled()) return@withLock fail(TraktFavoriteFailure.INCOGNITO, imported)+ val contentType = if (identity.type == TraktFavoriteType.MOVIE) ContentType.MOVIE else ContentType.SERIES+ val matchingIds = if (identity.type == TraktFavoriteType.MOVIE) {+ moviesByTmdb[identity.tmdbId].orEmpty().map { it.id }.distinct()+ } else {+ showsByTmdb[identity.tmdbId].orEmpty().map { it.id }.distinct()+ }+ if (matchingIds.isEmpty()) {+ unmatched+++ continue+ }+ for (contentId in matchingIds) {+ if (favorites.isFavorite(provider.id, contentId, contentType)) {+ alreadyPresent+++ } else if (favorites.addFavorite(provider.id, contentId, contentType).isSuccess) {+ imported+++ } else {+ return@withLock fail(TraktFavoriteFailure.REQUEST_FAILED, imported)+ }+ }+ }+ TraktFavoriteImportResult.Success(imported, alreadyPresent, unmatched, skipped)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ fail(TraktFavoriteFailure.REQUEST_FAILED, imported)+ }+ }+ }++ private fun fail(reason: TraktFavoriteFailure, imported: Int = 0) =+ TraktFavoriteImportResult.Failure(reason, imported)++ private companion object {+ const val MAX_PAGES = 50+ }+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktFavoritesService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktFavoritesService.ktnew file mode 100644index 00000000..e823924a--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktFavoritesService.kt@@ -0,0 +1,60 @@+package com.streamvault.data.trakt++import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteWriteResult+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoritesSource+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import javax.inject.Inject+import javax.inject.Singleton++/** Keeps Trakt favorites writes scoped to the account that initiated the action. */+@Singleton+class TraktFavoritesService @Inject constructor(+ private val account: TraktAccount,+ private val source: TraktFavoritesSource,+ private val history: PlaybackHistoryRepository,+) : TraktFavorites {+ private val mutex = Mutex()++ override suspend fun setFavorited(+ identity: TraktFavoriteIdentity,+ favorited: Boolean,+ ): TraktFavoriteActionResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock failure(TraktFavoriteFailure.INCOGNITO)+ if (!account.state.value.connected) account.load()+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock failure(TraktFavoriteFailure.DISCONNECTED)++ when (source.setFavorited(identity, favorited)) {+ TraktFavoriteWriteResult.Success -> {+ if (!account.state.value.connected || account.state.value.username != owner) {+ failure(TraktFavoriteFailure.ACCOUNT_CHANGED)+ } else if (history.isIncognitoModeEnabled()) {+ failure(TraktFavoriteFailure.INCOGNITO)+ } else {+ TraktFavoriteActionResult.Success+ }+ }+ TraktFavoriteWriteResult.Disconnected -> failure(TraktFavoriteFailure.DISCONNECTED)+ TraktFavoriteWriteResult.Failed -> failure(TraktFavoriteFailure.REQUEST_FAILED)+ }+ } catch (exception: Exception) {+ if (exception is CancellationException) throw exception+ failure(TraktFavoriteFailure.REQUEST_FAILED)+ }+ }+ }++ private fun failure(reason: TraktFavoriteFailure) = TraktFavoriteActionResult.Failure(reason)+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktHistorySyncService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktHistorySyncService.ktnew file mode 100644index 00000000..bd208b79--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktHistorySyncService.kt@@ -0,0 +1,214 @@+package com.streamvault.data.trakt++import com.streamvault.data.local.dao.EpisodeDao+import com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.SeriesDao+import com.streamvault.data.mapper.toDomain+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.PlaybackHistory+import com.streamvault.domain.model.PlaybackWatchedStatus+import com.streamvault.domain.model.Result+import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.*+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import kotlinx.coroutines.flow.first+import javax.inject.Inject+import javax.inject.Singleton++/** Manual additive import. All network pages are staged before the first local write. */+@Singleton+class TraktHistorySyncService @Inject constructor(+ private val account: TraktAccount,+ private val source: TraktHistorySource,+ private val movies: MovieDao,+ private val series: SeriesDao,+ private val episodes: EpisodeDao,+ private val history: PlaybackHistoryRepository,+) : TraktHistorySync {+ private val mutex = Mutex()+ override suspend fun sync(): TraktHistorySyncResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ var imported = 0+ var uploaded = 0+ try {+ if (history.isIncognitoModeEnabled()) {+ return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.INCOGNITO)+ }+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.DISCONNECTED)+ fun sameAccount() = account.state.value.connected && account.state.value.username == owner+ val entries = mutableListOf<TraktHistoryEntry>()+ var skipped = 0+ for (page in 1..50) {+ if (!sameAccount()) return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.ACCOUNT_CHANGED)+ when (val result = source.history(page)) {+ is TraktHistoryResult.Success -> {+ if (result.history.page != page || result.history.entries.size > 100) {+ return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.READ_FAILED)+ }+ entries += result.history.entries+ skipped += result.history.skippedEntries+ if (!result.history.hasMore) break+ if (page == 50) return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.READ_LIMIT)+ }+ else -> return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.READ_FAILED)+ }+ }+ val index = TraktHistoryIndex(entries)+ if (!sameAccount()) return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.ACCOUNT_CHANGED)+ val identities = entries.map { it.media }.distinct()+ val movieIds = identities.filterIsInstance<TraktMediaIdentity.MovieId>().map { it.tmdbId }+ val showIds = identities.filterIsInstance<TraktMediaIdentity.EpisodeId>().map { it.showTmdbId }.distinct()+ val movieRows = movieIds.chunked(400).flatMap { movies.getByTmdbIdsSync(it) }.groupBy { it.tmdbId }+ val showRows = showIds.chunked(400).flatMap { series.getByTmdbIdsSync(it) }.map { it.toDomain() }.groupBy { it.tmdbId }+ val episodeCache = mutableMapOf<Long, List<com.streamvault.domain.model.Episode>>()+ var unchanged = 0+ var unmatched = 0+ for (identity in identities) {+ if (!sameAccount()) return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.ACCOUNT_CHANGED, imported)+ val match = index.find(identity)+ if (match == null) { unmatched++; continue }+ val candidates = when (identity) {+ is TraktMediaIdentity.MovieId -> movieRows[identity.tmdbId].orEmpty().map { row ->+ val movie = row.toDomain()+ PlaybackHistory(contentId = movie.id, contentType = ContentType.MOVIE,+ providerId = movie.providerId, title = movie.name, posterUrl = movie.posterUrl,+ streamUrl = movie.streamUrl, totalDurationMs = movie.durationSeconds.toLong() * 1000,+ resumePositionMs = movie.watchProgress, lastWatchedAt = movie.lastWatchedAt,+ watchCount = row.watchCount.coerceAtLeast(1))+ }+ is TraktMediaIdentity.EpisodeId -> showRows[identity.showTmdbId].orEmpty().flatMap { show ->+ val localEpisodes = episodeCache[show.id] ?: episodes.getEntitiesBySeriesSync(show.id)+ .map { it.toDomain() }.also { episodeCache[show.id] = it }+ localEpisodes.filter { TraktMediaIdentityResolver.episode(show, it) == identity }.map { episode ->+ PlaybackHistory(contentId = episode.id, contentType = ContentType.SERIES_EPISODE,+ providerId = episode.providerId, title = "${show.name} - ${episode.title}",+ posterUrl = episode.coverUrl ?: show.posterUrl, streamUrl = episode.streamUrl,+ totalDurationMs = episode.durationSeconds.toLong() * 1000, seriesId = show.id,+ seasonNumber = episode.seasonNumber, episodeNumber = episode.episodeNumber,+ resumePositionMs = episode.watchProgress, lastWatchedAt = episode.lastWatchedAt)+ }+ }+ }+ if (candidates.isEmpty()) unmatched+++ for (candidate in candidates) {+ if (!sameAccount()) return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.ACCOUNT_CHANGED, imported)+ when (val result = history.importTraktHistory(candidate, identity, match)) {+ is Result.Success -> if (result.data) imported++ else unchanged+++ else -> return@withLock TraktHistorySyncResult.Failure(TraktSyncFailure.IMPORT_FAILED, imported)+ }+ }+ }+ // Upload only the newest durable completion per exact media identity. Existing+ // Trakt entries (including imported entries) are reconciled before any POST.+ if (!sameAccount()) return@withLock TraktHistorySyncResult.Failure(+ TraktSyncFailure.ACCOUNT_CHANGED, imported, uploaded)+ val firstLocalRows = history.getRecentlyWatched(limit = LOCAL_HISTORY_PAGE_SIZE + 1).first()+ var localRows = firstLocalRows.take(LOCAL_HISTORY_PAGE_SIZE)+ var localOffset = localRows.size+ var hasMoreLocalRows = firstLocalRows.size > LOCAL_HISTORY_PAGE_SIZE+ val localEpisodes = mutableMapOf<Long, List<com.streamvault.domain.model.Episode>>()+ val newestByIdentity = linkedMapOf<TraktMediaIdentity, TraktHistoryUpload>()+ var unresolvedLocal = 0+ while (localRows.isNotEmpty()) {+ if (!sameAccount()) return@withLock TraktHistorySyncResult.Failure(+ TraktSyncFailure.ACCOUNT_CHANGED, imported, uploaded)+ val completedRows = localRows.filter { row ->+ row.providerId > 0 && row.lastWatchedAt > 0 &&+ row.watchedStatus in setOf(+ PlaybackWatchedStatus.COMPLETED_AUTO,+ PlaybackWatchedStatus.COMPLETED_MANUAL,+ )+ }+ val movieIdsToResolve = completedRows+ .filter { it.contentType == ContentType.MOVIE }+ .map { it.contentId }+ .distinct()+ val localMovies = movieIdsToResolve.chunked(400)+ .flatMap { movies.getByIdsSync(it) }+ .associateBy { it.id }+ val showIdsToResolve = completedRows+ .filter { it.contentType == ContentType.SERIES_EPISODE }+ .mapNotNull { it.seriesId }+ .distinct()+ val localShows = showIdsToResolve.chunked(400)+ .flatMap { series.getByIdsSync(it) }+ .map { it.toDomain() }+ .associateBy { it.id }+ for (row in completedRows) {+ val identity = when (row.contentType) {+ ContentType.MOVIE -> localMovies[row.contentId]?.toDomain()+ ?.let(TraktMediaIdentityResolver::movie)+ ContentType.SERIES_EPISODE -> {+ val showId = row.seriesId+ val show = showId?.let(localShows::get)+ val episode = if (showId == null) null else (localEpisodes[showId]+ ?: episodes.getEntitiesBySeriesSync(showId).map { it.toDomain() }+ .also { localEpisodes[showId] = it })+ .firstOrNull { it.id == row.contentId && it.providerId == row.providerId }+ if (show != null && episode != null) {+ TraktMediaIdentityResolver.episode(show, episode)+ } else null+ }+ else -> null+ }+ if (identity == null) {+ unresolvedLocal+++ } else {+ val upload = TraktHistoryUpload(identity, row.lastWatchedAt)+ val existing = newestByIdentity[identity]+ if (existing == null || upload.watchedAtMs > existing.watchedAtMs) {+ newestByIdentity[identity] = upload+ }+ }+ }++ if (!hasMoreLocalRows) break+ if (history.isIncognitoModeEnabled()) return@withLock TraktHistorySyncResult.Failure(+ TraktSyncFailure.INCOGNITO, imported, uploaded)+ localRows = history.getRecentlyWatchedPage(+ offset = localOffset,+ limit = LOCAL_HISTORY_PAGE_SIZE,+ )+ localOffset += localRows.size+ hasMoreLocalRows = localRows.size == LOCAL_HISTORY_PAGE_SIZE+ }+ val missingEvents = newestByIdentity.values.filterNot { index.contains(it.media, it.watchedAtMs) }+ val uploadBatch = missingEvents.take(MAX_UPLOADS_PER_SYNC)+ if (!sameAccount()) return@withLock TraktHistorySyncResult.Failure(+ TraktSyncFailure.ACCOUNT_CHANGED, imported, uploaded)+ if (history.isIncognitoModeEnabled()) return@withLock TraktHistorySyncResult.Failure(+ TraktSyncFailure.INCOGNITO, imported, uploaded)+ if (uploadBatch.isNotEmpty()) {+ when (val result = source.upload(owner, uploadBatch)) {+ is TraktHistoryUploadResult.Success -> {+ uploaded += result.uploaded+ unmatched += result.unmatched + unresolvedLocal+ }+ TraktHistoryUploadResult.Disconnected -> return@withLock TraktHistorySyncResult.Failure(+ TraktSyncFailure.DISCONNECTED, imported, uploaded)+ TraktHistoryUploadResult.Failed -> return@withLock TraktHistorySyncResult.Failure(+ TraktSyncFailure.UPLOAD_FAILED, imported, uploaded)+ }+ } else {+ unmatched += unresolvedLocal+ }+ TraktHistorySyncResult.Success(imported, unchanged, unmatched, skipped, uploaded,+ moreUploads = missingEvents.size > MAX_UPLOADS_PER_SYNC)+ } catch (cancelled: CancellationException) {+ throw cancelled+ } catch (failure: Exception) {+ TraktHistorySyncResult.Failure(TraktSyncFailure.IMPORT_FAILED, imported, uploaded)+ }+ }+ }++ private companion object {+ const val LOCAL_HISTORY_PAGE_SIZE = 5_000+ const val MAX_UPLOADS_PER_SYNC = 100+ }+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktModels.kt b/data/src/main/java/com/streamvault/data/trakt/TraktModels.ktnew file mode 100644index 00000000..8451ee5d--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktModels.kt@@ -0,0 +1,115 @@+package com.streamvault.data.trakt++import com.google.gson.annotations.SerializedName+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoritePage+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktUserProfile+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingPage+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktCustomListItemIdentity+import com.streamvault.domain.trakt.TraktCustomListItemType+import com.streamvault.domain.trakt.TraktCustomListItemsPage+import com.streamvault.domain.trakt.TraktCustomListsPageResult+import com.streamvault.domain.trakt.TraktDiscoveryCategory+import com.streamvault.domain.trakt.TraktDiscoveryPage+import java.net.URI++class TraktConfig(val clientId: String, val redirectUri: String) {+ val configured: Boolean get() = clientId.isNotBlank() && runCatching {+ val uri = URI(redirectUri)+ uri.scheme == "https" && !uri.host.isNullOrBlank() && uri.host != "localhost" &&+ uri.rawUserInfo == null && uri.rawQuery == null && uri.rawFragment == null &&+ uri.port == -1 && !uri.path.isNullOrBlank()+ }.getOrDefault(false)+}++// Deliberately avoid data-class toString() on credential-bearing types.+class TraktTokens(+ @SerializedName("access_token") val accessToken: String,+ @SerializedName("refresh_token") val refreshToken: String,+ @SerializedName("created_at") val createdAt: Long,+ @SerializedName("expires_in") val expiresIn: Long,+) {+ fun usable(now: Long): Boolean = accessToken.isNotBlank() && refreshToken.isNotBlank() &&+ expiresIn > 0 && createdAt > 0 && now < createdAt + expiresIn - 60+}++class TraktPendingLogin(+ @SerializedName("verifier") val verifier: String,+ @SerializedName("state") val state: String,+ @SerializedName("created_at") val createdAt: Long,+)+class TraktStoredSession(+ @SerializedName("tokens") val tokens: TraktTokens? = null,+ @SerializedName("pending") val pending: TraktPendingLogin? = null,+)++interface TraktTokenStore {+ fun read(): TraktStoredSession+ /** Replace the entire record atomically, including both rotating tokens. */+ fun write(session: TraktStoredSession)+}++class TraktApiException(val status: Int, val oauthError: String? = null, val retryAfterSeconds: Long? = null) :+ Exception("Trakt request failed (HTTP $status)")++interface TraktApi {+ suspend fun exchange(code: String, verifier: String): TraktTokens+ suspend fun refresh(refreshToken: String): TraktTokens+ suspend fun username(accessToken: String): String+ suspend fun profile(accessToken: String): TraktUserProfile = TraktUserProfile(username(accessToken))+}++interface TraktPlaybackApi {+ /** False means metadata did not resolve unambiguously; no scrobble was submitted. */+ suspend fun scrobble(accessToken: String, event: com.streamvault.domain.trakt.TraktScrobbleEvent): Boolean+}++interface TraktHistoryApi {+ suspend fun history(accessToken: String, page: Int): com.streamvault.domain.trakt.TraktHistoryPage+ suspend fun upload(accessToken: String,+ events: List<com.streamvault.domain.trakt.TraktHistoryUpload>): com.streamvault.domain.trakt.TraktHistoryUploadResult+}++interface TraktWatchlistApi {+ suspend fun watchlist(accessToken: String, type: com.streamvault.domain.trakt.TraktWatchlistType,+ page: Int): com.streamvault.domain.trakt.TraktWatchlistPage+ /** A successful response means Trakt processed the request; transport failures are not retried. */+ suspend fun setWatchlisted(accessToken: String,+ identity: com.streamvault.domain.trakt.TraktWatchlistIdentity, watchlisted: Boolean)+}++interface TraktFavoritesApi {+ suspend fun favorites(accessToken: String, type: TraktFavoriteType, page: Int): TraktFavoritePage =+ TraktFavoritePage(emptyList(), page, hasMore = false)+ /** A successful response means Trakt processed the favorite add/remove request. */+ suspend fun setFavorited(accessToken: String, identity: TraktFavoriteIdentity, favorited: Boolean)+}++interface TraktRatingsApi {+ suspend fun ratings(accessToken: String, type: TraktRatingType, page: Int): TraktRatingPage+ /** A successful response means Trakt accepted or replaced the user's rating. */+ suspend fun setRating(accessToken: String, identity: TraktRatingIdentity, rating: Int)+}++interface TraktCustomListsApi {+ suspend fun lists(accessToken: String): List<com.streamvault.domain.trakt.TraktCustomList>+ suspend fun items(+ accessToken: String,+ listId: Long,+ type: TraktCustomListItemType,+ page: Int,+ ): TraktCustomListItemsPage+ suspend fun createList(accessToken: String, name: String, description: String?): com.streamvault.domain.trakt.TraktCustomList+ suspend fun deleteList(accessToken: String, listId: Long)+ suspend fun reorderLists(accessToken: String, listIds: List<Long>)+ suspend fun reorderItems(accessToken: String, listId: Long, listItemIds: List<Long>)+ suspend fun setItem(accessToken: String, listId: Long, identity: TraktCustomListItemIdentity, included: Boolean)+}++interface TraktDiscoveryApi {+ /** Public endpoint: only the Trakt Client ID header is required. */+ suspend fun discover(category: TraktDiscoveryCategory, page: Int): TraktDiscoveryPage+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktPkce.kt b/data/src/main/java/com/streamvault/data/trakt/TraktPkce.ktnew file mode 100644index 00000000..cc24b4cd--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktPkce.kt@@ -0,0 +1,13 @@+package com.streamvault.data.trakt++import java.security.MessageDigest+import java.security.SecureRandom+import java.util.Base64++internal object TraktPkce {+ private val random = SecureRandom()+ fun randomValue(): String = Base64.getUrlEncoder().withoutPadding()+ .encodeToString(ByteArray(32).also(random::nextBytes))+ fun challenge(verifier: String): String = Base64.getUrlEncoder().withoutPadding()+ .encodeToString(MessageDigest.getInstance("SHA-256").digest(verifier.toByteArray(Charsets.US_ASCII)))+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktRatingsService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktRatingsService.ktnew file mode 100644index 00000000..9f22ef4f--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktRatingsService.kt@@ -0,0 +1,203 @@+package com.streamvault.data.trakt++import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktRatingActionResult+import com.streamvault.domain.trakt.TraktRatingFailure+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingPageResult+import com.streamvault.domain.trakt.TraktRatingRefreshResult+import com.streamvault.domain.trakt.TraktRatingWriteResult+import com.streamvault.domain.trakt.TraktRatings+import com.streamvault.domain.trakt.TraktRatingsSource+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktRatingsState+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import javax.inject.Inject+import javax.inject.Singleton++/** Keeps explicit rating writes scoped to the connected account that initiated them. */+@Singleton+class TraktRatingsService @Inject constructor(+ private val account: TraktAccount,+ private val source: TraktRatingsSource,+ private val history: PlaybackHistoryRepository,+) : TraktRatings {+ private val mutex = Mutex()+ private val mutableState = MutableStateFlow(TraktRatingsState())+ override val state = mutableState.asStateFlow()++ override suspend fun refresh(type: TraktRatingType, force: Boolean): TraktRatingRefreshResult =+ withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock refreshFailure(TraktRatingFailure.INCOGNITO)+ if (!account.state.value.connected) account.load()+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock refreshFailure(TraktRatingFailure.DISCONNECTED)+ fun sameAccount() = account.state.value.connected && account.state.value.username == owner++ val current = mutableState.value+ if (current.accountUsername != owner) {+ mutableState.value = TraktRatingsState(accountUsername = owner, connected = true)+ } else if (!force && current.loadedAtMs[type]?.let {+ System.currentTimeMillis() - it < CACHE_TTL_MS+ } == true+ ) {+ mutableState.value = current.copy(connected = true, failure = null)+ return@withLock TraktRatingRefreshResult.Success(+ current.ratings.keys.count { it.type == type },+ )+ }++ mutableState.value = mutableState.value.copy(+ connected = true,+ refreshing = mutableState.value.refreshing + type,+ failure = null,+ )+ val staged = linkedMapOf<TraktRatingIdentity, Int>()+ var skipped = 0+ var finished = false+ for (page in 1..MAX_PAGES) {+ if (!sameAccount()) return@withLock refreshFailure(TraktRatingFailure.ACCOUNT_CHANGED)+ if (history.isIncognitoModeEnabled()) return@withLock refreshFailure(TraktRatingFailure.INCOGNITO)+ when (val result = source.ratings(type, page)) {+ is TraktRatingPageResult.Success -> {+ val data = result.page+ if (data.page != page || data.items.size > PAGE_SIZE ||+ data.items.any { (identity, rating) -> identity.type != type || rating !in 1..10 }+ ) return@withLock refreshFailure(TraktRatingFailure.REQUEST_FAILED)+ data.items.forEach { (identity, rating) -> staged[identity] = rating }+ skipped += data.skippedItems+ if (!data.hasMore) {+ finished = true+ break+ }+ if (page == MAX_PAGES) return@withLock refreshFailure(TraktRatingFailure.READ_LIMIT)+ }+ TraktRatingPageResult.Disconnected ->+ return@withLock refreshFailure(TraktRatingFailure.DISCONNECTED)+ TraktRatingPageResult.Failed ->+ return@withLock refreshFailure(TraktRatingFailure.REQUEST_FAILED)+ }+ }+ if (!finished) return@withLock refreshFailure(TraktRatingFailure.READ_LIMIT)+ if (!sameAccount()) return@withLock refreshFailure(TraktRatingFailure.ACCOUNT_CHANGED)+ if (history.isIncognitoModeEnabled()) return@withLock refreshFailure(TraktRatingFailure.INCOGNITO)++ val afterRead = mutableState.value+ val merged = afterRead.ratings.filterKeys { it.type != type } + staged+ mutableState.value = afterRead.copy(+ accountUsername = owner,+ connected = true,+ ratings = merged,+ loadedTypes = afterRead.loadedTypes + type,+ loadedAtMs = afterRead.loadedAtMs + (type to System.currentTimeMillis()),+ refreshing = afterRead.refreshing - type,+ failure = null,+ )+ TraktRatingRefreshResult.Success(staged.size, skipped)+ } catch (exception: Exception) {+ if (exception is CancellationException) {+ mutableState.value = mutableState.value.copy(refreshing = emptySet())+ throw exception+ }+ refreshFailure(TraktRatingFailure.REQUEST_FAILED)+ }+ }+ }++ override suspend fun setRating(+ identity: TraktRatingIdentity,+ rating: Int,+ ): TraktRatingActionResult = withContext(Dispatchers.IO) {+ require(rating in 1..10)+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock failure(TraktRatingFailure.INCOGNITO)+ if (!account.state.value.connected) account.load()+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock failure(TraktRatingFailure.DISCONNECTED)++ if (mutableState.value.accountUsername != owner) {+ mutableState.value = TraktRatingsState(accountUsername = owner, connected = true)+ }++ mutableState.value = mutableState.value.copy(+ accountUsername = owner,+ connected = true,+ updating = mutableState.value.updating + identity,+ failure = null,+ )+ when (source.setRating(identity, rating)) {+ TraktRatingWriteResult.Success -> {+ if (!account.state.value.connected || account.state.value.username != owner) {+ failure(TraktRatingFailure.ACCOUNT_CHANGED)+ } else if (history.isIncognitoModeEnabled()) {+ failure(TraktRatingFailure.INCOGNITO)+ } else {+ val current = mutableState.value+ mutableState.value = current.copy(+ ratings = current.ratings + (identity to rating),+ updating = current.updating - identity,+ failure = null,+ )+ TraktRatingActionResult.Success+ }+ }+ TraktRatingWriteResult.Disconnected -> failure(TraktRatingFailure.DISCONNECTED)+ TraktRatingWriteResult.Failed -> failure(TraktRatingFailure.REQUEST_FAILED)+ }+ } catch (exception: Exception) {+ if (exception is CancellationException) throw exception+ failure(TraktRatingFailure.REQUEST_FAILED)+ } finally {+ val current = mutableState.value+ mutableState.value = current.copy(updating = current.updating - identity)+ }+ }+ }++ private fun refreshFailure(reason: TraktRatingFailure): TraktRatingRefreshResult.Failure {+ val current = mutableState.value+ val clear = reason == TraktRatingFailure.DISCONNECTED || reason == TraktRatingFailure.INCOGNITO ||+ reason == TraktRatingFailure.ACCOUNT_CHANGED+ mutableState.value = current.copy(+ connected = account.state.value.connected,+ ratings = if (clear) emptyMap() else current.ratings,+ loadedTypes = if (clear) emptySet() else current.loadedTypes,+ loadedAtMs = if (clear) emptyMap() else current.loadedAtMs,+ refreshing = emptySet(),+ updating = if (clear) emptySet() else current.updating,+ failure = reason,+ )+ return TraktRatingRefreshResult.Failure(reason)+ }++ private fun failure(reason: TraktRatingFailure): TraktRatingActionResult.Failure {+ val current = mutableState.value+ val clear = reason == TraktRatingFailure.DISCONNECTED || reason == TraktRatingFailure.INCOGNITO ||+ reason == TraktRatingFailure.ACCOUNT_CHANGED+ mutableState.value = current.copy(+ connected = account.state.value.connected,+ ratings = if (clear) emptyMap() else current.ratings,+ loadedTypes = if (clear) emptySet() else current.loadedTypes,+ loadedAtMs = if (clear) emptyMap() else current.loadedAtMs,+ updating = emptySet(),+ failure = reason,+ )+ return TraktRatingActionResult.Failure(reason)+ }++ private companion object {+ const val PAGE_SIZE = 100+ const val MAX_PAGES = 50+ const val CACHE_TTL_MS = 5 * 60 * 1000L+ }+}diff --git a/data/src/main/java/com/streamvault/data/trakt/TraktWatchlistService.kt b/data/src/main/java/com/streamvault/data/trakt/TraktWatchlistService.ktnew file mode 100644index 00000000..e5c32d7d--- /dev/null+++ b/data/src/main/java/com/streamvault/data/trakt/TraktWatchlistService.kt@@ -0,0 +1,193 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistActionResult+import com.streamvault.domain.trakt.TraktWatchlistFailure+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistPageResult+import com.streamvault.domain.trakt.TraktWatchlistRefreshResult+import com.streamvault.domain.trakt.TraktWatchlistSource+import com.streamvault.domain.trakt.TraktWatchlistState+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktWatchlistWriteResult+import com.streamvault.domain.repository.PlaybackHistoryRepository+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import javax.inject.Inject+import javax.inject.Singleton++/** Manual Trakt watchlist access. Pages are staged before replacing the account-scoped cache. */+@Singleton+class TraktWatchlistService @Inject constructor(+ private val account: TraktAccount,+ private val source: TraktWatchlistSource,+ private val history: PlaybackHistoryRepository,+) : TraktWatchlist {+ private val mutex = Mutex()+ private val mutableState = MutableStateFlow(TraktWatchlistState())+ override val state = mutableState.asStateFlow()++ override suspend fun refresh(force: Boolean): TraktWatchlistRefreshResult = withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock fail(TraktWatchlistFailure.INCOGNITO)+ if (!account.state.value.connected) account.load()+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock fail(TraktWatchlistFailure.DISCONNECTED)+ fun sameAccount() = account.state.value.connected && account.state.value.username == owner++ val current = mutableState.value+ if (current.accountUsername != owner) {+ mutableState.value = TraktWatchlistState(accountUsername = owner, connected = true)+ } else if (!force && current.loadedAtMs?.let { System.currentTimeMillis() - it < CACHE_TTL_MS } == true) {+ mutableState.value = current.copy(connected = true, failure = null)+ return@withLock TraktWatchlistRefreshResult.Success(current.items.size)+ }+ mutableState.value = mutableState.value.copy(connected = true, isRefreshing = true, failure = null)++ val staged = linkedSetOf<TraktWatchlistIdentity>()+ var skipped = 0+ for (type in TraktWatchlistType.entries) {+ var finished = false+ for (page in 1..MAX_PAGES) {+ if (!sameAccount()) return@withLock fail(TraktWatchlistFailure.ACCOUNT_CHANGED)+ if (history.isIncognitoModeEnabled()) return@withLock fail(TraktWatchlistFailure.INCOGNITO)+ when (val result = source.watchlist(type, page)) {+ is TraktWatchlistPageResult.Success -> {+ val data = result.page+ if (data.page != page || data.items.size > PAGE_SIZE) {+ return@withLock fail(TraktWatchlistFailure.REQUEST_FAILED)+ }+ staged.addAll(data.items.filter { it.type == type })+ skipped += data.skippedItems+ if (!data.hasMore) {+ finished = true+ break+ }+ if (page == MAX_PAGES) return@withLock fail(TraktWatchlistFailure.READ_LIMIT)+ }+ TraktWatchlistPageResult.Disconnected -> return@withLock fail(TraktWatchlistFailure.DISCONNECTED)+ TraktWatchlistPageResult.Failed -> return@withLock fail(TraktWatchlistFailure.REQUEST_FAILED)+ }+ }+ if (!finished) return@withLock fail(TraktWatchlistFailure.READ_LIMIT)+ }+ if (!sameAccount()) return@withLock fail(TraktWatchlistFailure.ACCOUNT_CHANGED)+ if (history.isIncognitoModeEnabled()) return@withLock fail(TraktWatchlistFailure.INCOGNITO)+ mutableState.value = TraktWatchlistState(+ accountUsername = owner,+ connected = true,+ items = staged,+ loadedAtMs = System.currentTimeMillis(),+ )+ TraktWatchlistRefreshResult.Success(staged.size, skipped)+ } catch (failure: Exception) {+ if (failure is CancellationException) {+ mutableState.value = mutableState.value.copy(isRefreshing = false, loadedAtMs = null)+ throw failure+ }+ fail(TraktWatchlistFailure.REQUEST_FAILED)+ }+ }+ }++ override suspend fun setWatchlisted(+ identity: TraktWatchlistIdentity,+ watchlisted: Boolean,+ ): TraktWatchlistActionResult {+ val loaded = mutableState.value+ if (!loaded.connected || loaded.accountUsername != account.state.value.username ||+ loaded.loadedAtMs?.let { System.currentTimeMillis() - it >= CACHE_TTL_MS } != false+ ) {+ when (val result = refresh()) {+ is TraktWatchlistRefreshResult.Failure -> return TraktWatchlistActionResult.Failure(result.reason)+ is TraktWatchlistRefreshResult.Success -> Unit+ }+ }++ return withContext(Dispatchers.IO) {+ mutex.withLock {+ try {+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktWatchlistFailure.INCOGNITO)+ val owner = account.state.value.username?.takeIf { account.state.value.connected }+ ?: return@withLock actionFailure(TraktWatchlistFailure.DISCONNECTED)+ val current = mutableState.value+ if (current.accountUsername != owner || !current.loaded) {+ return@withLock actionFailure(TraktWatchlistFailure.ACCOUNT_CHANGED)+ }+ val alreadyWatchlisted = current.contains(identity)+ if (alreadyWatchlisted == watchlisted) return@withLock TraktWatchlistActionResult.Success++ mutableState.value = current.copy(updating = current.updating + identity, failure = null)+ when (source.setWatchlisted(identity, watchlisted)) {+ TraktWatchlistWriteResult.Success -> {+ if (!account.state.value.connected || account.state.value.username != owner) {+ return@withLock actionFailure(TraktWatchlistFailure.ACCOUNT_CHANGED)+ }+ if (history.isIncognitoModeEnabled()) return@withLock actionFailure(TraktWatchlistFailure.INCOGNITO)+ val updated = mutableState.value.items.toMutableSet().apply {+ if (watchlisted) add(identity) else remove(identity)+ }+ mutableState.value = mutableState.value.copy(+ items = updated,+ loadedAtMs = System.currentTimeMillis(),+ updating = mutableState.value.updating - identity,+ failure = null,+ )+ TraktWatchlistActionResult.Success+ }+ TraktWatchlistWriteResult.Disconnected -> actionFailure(TraktWatchlistFailure.DISCONNECTED)+ TraktWatchlistWriteResult.Failed -> actionFailure(TraktWatchlistFailure.REQUEST_FAILED)+ }+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ actionFailure(TraktWatchlistFailure.REQUEST_FAILED)+ } finally {+ val current = mutableState.value+ if (identity in current.updating) {+ mutableState.value = current.copy(updating = current.updating - identity)+ }+ }+ }+ }+ }++ private fun fail(reason: TraktWatchlistFailure): TraktWatchlistRefreshResult.Failure {+ val current = mutableState.value+ mutableState.value = current.copy(+ connected = account.state.value.connected,+ isRefreshing = false,+ loadedAtMs = null,+ updating = emptySet(),+ failure = reason,+ items = if (reason == TraktWatchlistFailure.DISCONNECTED || reason == TraktWatchlistFailure.INCOGNITO ||+ reason == TraktWatchlistFailure.ACCOUNT_CHANGED) emptySet() else current.items,+ )+ return TraktWatchlistRefreshResult.Failure(reason)+ }++ private fun actionFailure(reason: TraktWatchlistFailure): TraktWatchlistActionResult.Failure {+ val current = mutableState.value+ mutableState.value = current.copy(+ connected = account.state.value.connected,+ loadedAtMs = null,+ updating = emptySet(),+ failure = reason,+ items = if (reason == TraktWatchlistFailure.DISCONNECTED || reason == TraktWatchlistFailure.INCOGNITO ||+ reason == TraktWatchlistFailure.ACCOUNT_CHANGED) emptySet() else current.items,+ )+ return TraktWatchlistActionResult.Failure(reason)+ }++ private companion object {+ const val PAGE_SIZE = 100+ const val MAX_PAGES = 50+ const val CACHE_TTL_MS = 5 * 60 * 1000L+ }+}diff --git a/data/src/test/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistryTest.kt b/data/src/test/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistryTest.ktindex b799d36a..b8ac373d 100644--- a/data/src/test/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistryTest.kt+++ b/data/src/test/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistryTest.kt@@ -27,5 +27,8 @@ class StreamVaultDatabaseMigrationRegistryTest {assertThat(StreamVaultDatabaseMigrationRegistry.v75To76.single().endVersion).isEqualTo(76)assertThat(StreamVaultDatabaseMigrationRegistry.v76To77.single().endVersion).isEqualTo(77)assertThat(StreamVaultDatabaseMigrationRegistry.v77To78.single().endVersion).isEqualTo(78)+ assertThat(StreamVaultDatabaseMigrationRegistry.v78To79.single().endVersion).isEqualTo(79)+ assertThat(StreamVaultDatabaseMigrationRegistry.v79To80.single().endVersion).isEqualTo(80)+ assertThat(StreamVaultDatabaseMigrationRegistry.v80To81.single().endVersion).isEqualTo(81)}}diff --git a/data/src/test/java/com/streamvault/data/preferences/PreferencesRepositoryTraktDiscoveryVisibilityTest.kt b/data/src/test/java/com/streamvault/data/preferences/PreferencesRepositoryTraktDiscoveryVisibilityTest.ktnew file mode 100644index 00000000..e1d56556--- /dev/null+++ b/data/src/test/java/com/streamvault/data/preferences/PreferencesRepositoryTraktDiscoveryVisibilityTest.kt@@ -0,0 +1,87 @@+package com.streamvault.data.preferences++import android.content.Context+import android.content.ContextWrapper+import androidx.datastore.preferences.preferencesDataStoreFile+import com.google.common.truth.Truth.assertThat+import com.streamvault.data.local.dao.ChannelPreferenceDao+import com.streamvault.data.local.dao.SearchHistoryDao+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.runBlocking+import java.io.File+import org.junit.After+import org.junit.Before+import org.junit.Test+import org.junit.runner.RunWith+import org.mockito.kotlin.mock+import org.robolectric.RobolectricTestRunner+import org.robolectric.RuntimeEnvironment++@RunWith(RobolectricTestRunner::class)+class PreferencesRepositoryTraktDiscoveryVisibilityTest {+ private lateinit var context: Context+ private lateinit var isolatedDirectory: File++ @Before+ fun setUp() {+ isolatedDirectory = File(+ RuntimeEnvironment.getApplication().cacheDir,+ "trakt-discovery-preferences-${System.nanoTime()}"+ )+ isolatedDirectory.deleteRecursively()+ isolatedDirectory.mkdirs()+ context = object : ContextWrapper(RuntimeEnvironment.getApplication()) {+ override fun getFilesDir(): File = isolatedDirectory+ override fun getApplicationContext(): Context = this+ }+ context.preferencesDataStoreFile("user_preferences").delete()+ }++ @After+ fun tearDown() {+ context.preferencesDataStoreFile("user_preferences").delete()+ isolatedDirectory.deleteRecursively()+ }++ @Test+ fun `Trakt discovery categories default visible and persist independently`() = runBlocking {+ val repository = repository()++ assertThat(repository.showTraktTrendingMovies.first()).isTrue()+ assertThat(repository.showTraktPopularMovies.first()).isTrue()+ assertThat(repository.showTraktTrendingSeries.first()).isTrue()+ assertThat(repository.showTraktPopularSeries.first()).isTrue()++ repository.setShowTraktTrendingMovies(false)++ assertThat(repository.showTraktTrendingMovies.first()).isFalse()+ assertThat(repository.showTraktPopularMovies.first()).isTrue()+ assertThat(repository.showTraktTrendingSeries.first()).isTrue()+ assertThat(repository.showTraktPopularSeries.first()).isTrue()+ }++ @Test+ fun `Trakt playback scrobbling preference defaults on and can be disabled`() = runBlocking {+ val repository = repository()++ assertThat(repository.scrobblingEnabled.first()).isTrue()+ repository.setScrobblingEnabled(false)+ assertThat(repository.scrobblingEnabled.first()).isFalse()+ }++ @Test+ fun `Trakt history sync preference defaults on and can be disabled`() = runBlocking {+ val repository = repository()++ assertThat(repository.historySyncEnabled.first()).isTrue()+ repository.setHistorySyncEnabled(false)+ assertThat(repository.historySyncEnabled.first()).isFalse()+ }++ private fun repository() = PreferencesRepository(+ context = context,+ channelPreferenceDao = mock<ChannelPreferenceDao>(),+ searchHistoryDao = mock<SearchHistoryDao>(),+ corruptionRecovery = mock<PreferencesCorruptionRecovery>()+ )+}diff --git a/data/src/test/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImplTest.ktindex 786fc287..c59f8e0e 100644--- a/data/src/test/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImplTest.kt+++ b/data/src/test/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImplTest.kt@@ -8,6 +8,7 @@ import com.streamvault.data.local.dao.PlaybackHistoryDaoimport com.streamvault.data.local.entity.PlaybackHistoryEntityimport com.streamvault.data.local.entity.PlaybackHistoryLiteEntityimport com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.mapper.toEntityimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.PlaybackHistoryimport com.streamvault.domain.model.PlaybackWatchedStatus@@ -26,6 +27,45 @@ import org.mockito.kotlin.wheneverimport org.mockito.kotlin.checkclass PlaybackHistoryRepositoryImplTest {+ @Test fun `Trakt import respects current incognito preference without waiting for state collection`() = runTest {+ whenever(preferencesRepository.isIncognitoMode).thenReturn(flowOf(true))+ val identity = com.streamvault.domain.trakt.TraktMediaIdentity.MovieId(603)+ assertThat(repository().importTraktHistory(movieHistory(), identity,+ com.streamvault.domain.trakt.TraktHistoryMatch(identity, 2000, 1)).getOrNull()).isFalse()+ verify(historyDao, never()).insertOrUpdate(org.mockito.kotlin.any())+ }+ @Test fun `Trakt import is idempotent and preserves remote time count and completion`() = runTest {+ whenever(preferencesRepository.isIncognitoMode).thenReturn(flowOf(false))+ val original = movieHistory().copy(lastWatchedAt = 1000, watchCount = 4)+ var stored = original.toEntity()+ whenever(historyDao.get(10, ContentType.MOVIE.name, 5)).thenAnswer { stored }+ org.mockito.kotlin.doAnswer {+ stored = it.getArgument(0)+ Unit+ }.whenever(historyDao).insertOrUpdate(org.mockito.kotlin.any())+ val repository = repository()+ val identity = com.streamvault.domain.trakt.TraktMediaIdentity.MovieId(603)+ val match = com.streamvault.domain.trakt.TraktHistoryMatch(identity, 2000, 2)+ assertThat(repository.importTraktHistory(original, identity, match).getOrNull()).isTrue()+ assertThat(repository.importTraktHistory(original, identity, match).getOrNull()).isFalse()+ assertThat(stored.lastWatchedAt).isEqualTo(2000)+ assertThat(stored.watchCount).isEqualTo(4)+ assertThat(stored.resumePositionMs).isEqualTo(original.totalDurationMs)+ assertThat(stored.watchedStatus).isEqualTo(PlaybackWatchedStatus.COMPLETED_AUTO.name)+ verify(historyDao, times(1)).insertOrUpdate(org.mockito.kotlin.any())+ verify(movieDao, times(1)).syncWatchProgressFromHistory(10, 5)+ }++ @Test fun `Trakt import rechecks persisted newer progress before writing`() = runTest {+ whenever(preferencesRepository.isIncognitoMode).thenReturn(flowOf(false))+ val base = movieHistory().copy(lastWatchedAt = 1000)+ val newer = base.copy(lastWatchedAt = 3000)+ whenever(historyDao.get(10, ContentType.MOVIE.name, 5)).thenReturn(newer.toEntity())+ val identity = com.streamvault.domain.trakt.TraktMediaIdentity.MovieId(603)+ assertThat(repository().importTraktHistory(base, identity,+ com.streamvault.domain.trakt.TraktHistoryMatch(identity, 2000, 1)).getOrNull()).isFalse()+ verify(historyDao, never()).insertOrUpdate(org.mockito.kotlin.any())+ }private val historyDao: PlaybackHistoryDao = mock()private val preferencesRepository: PreferencesRepository = mock()diff --git a/data/src/test/java/com/streamvault/data/trakt/EncryptedTraktTokenStoreTest.kt b/data/src/test/java/com/streamvault/data/trakt/EncryptedTraktTokenStoreTest.ktnew file mode 100644index 00000000..9e7a713d--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/EncryptedTraktTokenStoreTest.kt@@ -0,0 +1,53 @@+package com.streamvault.data.trakt++import android.content.Context+import org.robolectric.RuntimeEnvironment+import com.streamvault.data.security.CredentialCrypto+import org.junit.Assert.*+import org.junit.Test+import org.junit.runner.RunWith+import org.robolectric.RobolectricTestRunner+import java.io.File+import java.util.Base64++@RunWith(RobolectricTestRunner::class)+class EncryptedTraktTokenStoreTest {+ // Reversible encoding is only a test double, not production encryption.+ private class Crypto : CredentialCrypto {+ var fail = false+ override fun encryptIfNeeded(value: String): String {+ if (fail) throw SecurityException("Test encryption failure")+ return "enc:test:" + Base64.getEncoder().encodeToString(value.toByteArray())+ }+ override fun decryptIfNeeded(value: String) = String(Base64.getDecoder().decode(value.removePrefix("enc:test:")))+ }++ @Test fun `encrypted no backup record rotates tokens together and survives recreation`() {+ val context: Context = RuntimeEnvironment.getApplication()+ val crypto = Crypto()+ val store = EncryptedTraktTokenStore(context, crypto)+ store.write(TraktStoredSession(pending = TraktPendingLogin("pending-verifier", "pending-state", 2000000)))+ val pending = EncryptedTraktTokenStore(context, crypto).read().pending!!+ assertEquals("pending-verifier", pending.verifier)+ assertEquals("pending-state", pending.state)+ assertEquals(2000000L, pending.createdAt)+ assertFalse(File(context.noBackupFilesDir, "trakt_session").readText().contains("pending-verifier"))+ store.write(TraktStoredSession(TraktTokens("old-access", "old-refresh", 2000000, 604800)))+ val file = File(context.noBackupFilesDir, "trakt_session")+ assertTrue(file.exists())+ assertFalse(file.readText().contains("old-access"))+ store.write(TraktStoredSession(TraktTokens("new-access", "new-refresh", 2000001, 604800)))+ val recreated = EncryptedTraktTokenStore(context, crypto).read()+ assertEquals("new-access", recreated.tokens!!.accessToken)+ assertEquals("new-refresh", recreated.tokens.refreshToken)+ crypto.fail = true+ try {+ store.write(TraktStoredSession(TraktTokens("failed-access", "failed-refresh", 2000002, 604800)))+ fail("Expected encryption failure")+ } catch (_: SecurityException) { }+ assertEquals("new-refresh", store.read().tokens!!.refreshToken)+ store.write(TraktStoredSession()) // Clearing works even if the Keystore is broken.+ assertFalse(file.exists())+ assertNull(store.read().tokens)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktAccountIntegrationTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktAccountIntegrationTest.ktnew file mode 100644index 00000000..4e90e1dd--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktAccountIntegrationTest.kt@@ -0,0 +1,112 @@+package com.streamvault.data.trakt++import android.content.Context+import com.google.gson.Gson+import com.google.gson.JsonObject+import com.streamvault.data.security.AndroidKeystoreCredentialCrypto+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.*+import org.junit.Test+import org.junit.runner.RunWith+import org.robolectric.RobolectricTestRunner+import org.robolectric.RuntimeEnvironment+import java.io.File+import java.net.URI+import java.net.URLDecoder+import java.util.concurrent.TimeUnit++/** Local acceptance coverage using the real HTTP client, crypto and disk store.+ * Browser consent and Android App Link delivery still require a real device test.+ */+@RunWith(RobolectricTestRunner::class)+class TraktAccountIntegrationTest {+ private val config = TraktConfig("public-client", "https://streamvault.test/oauth/trakt/callback/index.html")+ private var now = 2000000L+ private val context: Context get() = RuntimeEnvironment.getApplication()+ private fun store() = EncryptedTraktTokenStore(context, AndroidKeystoreCredentialCrypto(context))+ private fun account(server: MockWebServer) = TraktAuthService(config, store(),+ TraktApiClient(config, OkHttpClient.Builder().callTimeout(5, TimeUnit.SECONDS).build(), server.url("/"))) { now }+ private fun state(url: String) = URI(url).rawQuery.split('&').associate {+ val parts = it.split('=', limit = 2)+ parts[0] to URLDecoder.decode(parts[1], "UTF-8")+ }.getValue("state")+ private fun tokenResponse(access: String, refresh: String) = MockResponse().setBody(+ """{"access_token":"$access","refresh_token":"$refresh","created_at":$now,"expires_in":604800}""")+ private fun profileResponse() = MockResponse().setBody("""{"user":{"username":"viewer"}}""")++ @Test fun `login survives restart and persists rotating token pair through HTTP and encryption`() = runBlocking {+ MockWebServer().use { server ->+ store().write(TraktStoredSession())+ val first = account(server)+ val state = state(first.beginSignIn())+ val verifier = store().read().pending!!.verifier+ val restored = account(server)+ restored.load()+ assertTrue(restored.state.value.connecting)+ server.enqueue(tokenResponse("first-access", "first-refresh"))+ server.enqueue(profileResponse())+ restored.completeSignIn("${config.redirectUri}?code=authorization-code&state=$state")+ assertTrue(restored.state.value.connected)+ assertEquals("viewer", restored.state.value.username)+ val exchange = server.takeRequest(5, TimeUnit.SECONDS)!!+ assertEquals("/oauth/token", exchange.path)+ val exchangeBody = Gson().fromJson(exchange.body.readUtf8(), JsonObject::class.java)+ assertEquals(verifier, exchangeBody["code_verifier"].asString)+ assertEquals(config.redirectUri, exchangeBody["redirect_uri"].asString)+ assertEquals("Bearer first-access", server.takeRequest(5, TimeUnit.SECONDS)!!.getHeader("Authorization"))+ val record = File(context.noBackupFilesDir, "trakt_session").readText()+ assertTrue(record.startsWith("enc:v1:"))+ assertFalse(record.contains("first-access"))+ assertFalse(record.contains("first-refresh"))+ assertNull(store().read().pending)++ server.enqueue(profileResponse())+ val restarted = account(server)+ restarted.load()+ assertEquals("viewer", restarted.state.value.username)+ assertEquals("Bearer first-access", server.takeRequest(5, TimeUnit.SECONDS)!!.getHeader("Authorization"))+ now += 604801+ server.enqueue(tokenResponse("rotated-access", "rotated-refresh"))+ server.enqueue(profileResponse())+ restarted.refreshProfile()+ val refreshBody = Gson().fromJson(server.takeRequest(5, TimeUnit.SECONDS)!!.body.readUtf8(), JsonObject::class.java)+ assertEquals("refresh_token", refreshBody["grant_type"].asString)+ assertEquals("first-refresh", refreshBody["refresh_token"].asString)+ assertFalse(refreshBody.has("client_secret"))+ assertEquals("Bearer rotated-access", server.takeRequest(5, TimeUnit.SECONDS)!!.getHeader("Authorization"))+ val saved = store().read().tokens!!+ assertEquals("rotated-access", saved.accessToken)+ assertEquals("rotated-refresh", saved.refreshToken)++ restarted.disconnect()+ val disconnected = account(server)+ disconnected.load()+ assertFalse(disconnected.state.value.connected)+ assertFalse(File(context.noBackupFilesDir, "trakt_session").exists())+ }+ }++ @Test fun `denial and cancellation after restart leave no credentials and make no HTTP requests`() = runBlocking {+ MockWebServer().use { server ->+ for (denied in listOf(true, false)) {+ val state = state(account(server).beginSignIn())+ val restored = account(server)+ restored.load()+ if (denied) restored.completeSignIn("${config.redirectUri}?error=access_denied&state=$state")+ else {+ restored.cancelSignIn()+ restored.completeSignIn("${config.redirectUri}?code=late-code&state=$state")+ }+ assertFalse(restored.state.value.connected)+ assertFalse(restored.state.value.connecting)+ assertNull(restored.state.value.message)+ assertNull(store().read().pending)+ assertNull(store().read().tokens)+ }+ assertEquals(0, server.requestCount)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktApiClientTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktApiClientTest.ktnew file mode 100644index 00000000..9f0db172--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktApiClientTest.kt@@ -0,0 +1,219 @@+package com.streamvault.data.trakt++import com.google.gson.Gson+import com.google.gson.JsonObject+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingPage+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktCustomListItemIdentity+import com.streamvault.domain.trakt.TraktCustomListItemType+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.*+import org.junit.Test++class TraktApiClientTest {+ @Test fun `custom lists can be deleted and reordered with their Trakt ids`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setResponseCode(204))+ server.enqueue(MockResponse().setResponseCode(200).setBody("{}"))+ server.enqueue(MockResponse().setResponseCode(200).setBody("{}"))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))++ api.deleteList("access", 42)+ val deletion = server.takeRequest()+ assertEquals("DELETE", deletion.method)+ assertEquals("/users/me/lists/42", deletion.path)+ assertEquals("Bearer access", deletion.getHeader("Authorization"))++ api.reorderLists("access", listOf(42, 17, 99))+ val reorder = server.takeRequest()+ assertEquals("POST", reorder.method)+ assertEquals("/users/me/lists/reorder", reorder.path)+ val body = Gson().fromJson(reorder.body.readUtf8(), JsonObject::class.java)+ assertEquals(listOf(42L, 17L, 99L), body.getAsJsonArray("rank").map { it.asLong })++ api.reorderItems("access", 42, listOf(7002, 7001))+ val itemReorder = server.takeRequest()+ assertEquals("POST", itemReorder.method)+ assertEquals("/users/me/lists/42/items/reorder", itemReorder.path)+ assertEquals(listOf(7002L, 7001L), Gson().fromJson(itemReorder.body.readUtf8(), JsonObject::class.java)+ .getAsJsonArray("rank").map { it.asLong })+ }+ }++ @Test fun `season and episode list items resolve exact Trakt media ids`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[{"type":"show","show":{"ids":{"tmdb":1396,"trakt":1}}}]"""))+ server.enqueue(MockResponse().setBody("""{"number":2,"ids":{"trakt":2002,"tmdb":111}}"""))+ server.enqueue(MockResponse().setResponseCode(201).setBody("{}"))+ server.enqueue(MockResponse().setBody("""[{"type":"show","show":{"ids":{"tmdb":1396,"trakt":1}}}]"""))+ server.enqueue(MockResponse().setBody("""{"season":2,"number":5,"ids":{"trakt":2055,"tmdb":222}}"""))+ server.enqueue(MockResponse().setResponseCode(201).setBody("{}"))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))++ api.setItem("access", 88, TraktCustomListItemIdentity(TraktCustomListItemType.SEASON, 1396, 2), true)+ val seasonSearch = server.takeRequest()+ assertEquals("/search/tmdb/1396?type=show", seasonSearch.path)+ assertEquals("/shows/1/seasons/2", server.takeRequest().path)+ val seasonWrite = server.takeRequest()+ assertEquals("/users/me/lists/88/items", seasonWrite.path)+ assertEquals(2002L, Gson().fromJson(seasonWrite.body.readUtf8(), JsonObject::class.java)+ .getAsJsonArray("seasons")[0].asJsonObject.getAsJsonObject("ids")["trakt"].asLong)++ api.setItem("access", 88, TraktCustomListItemIdentity(TraktCustomListItemType.EPISODE, 1396, 2, 5), true)+ assertEquals("/search/tmdb/1396?type=show", server.takeRequest().path)+ assertEquals("/shows/1/seasons/2/episodes/5", server.takeRequest().path)+ val episodeWrite = server.takeRequest()+ assertEquals("/users/me/lists/88/items", episodeWrite.path)+ assertEquals(2055L, Gson().fromJson(episodeWrite.body.readUtf8(), JsonObject::class.java)+ .getAsJsonArray("episodes")[0].asJsonObject.getAsJsonObject("ids")["trakt"].asLong)+ }+ }++ @Test fun `custom list season and episode responses keep parent show identity`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[+ {"id":7001,"rank":1,"type":"season","season":{"number":2,"ids":{"trakt":2002}},"show":{"title":"Example","ids":{"tmdb":1396}}}+ ]"""))+ server.enqueue(MockResponse().setBody("""[+ {"id":7002,"rank":2,"type":"episode","episode":{"season":2,"number":5,"title":"The Test","ids":{"trakt":2055}},"show":{"title":"Example","ids":{"tmdb":1396}}}+ ]"""))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))++ val seasons = api.items("access", 88, TraktCustomListItemType.SEASON, 1)+ assertEquals("/users/me/lists/88/items/seasons?page=1&limit=250&extended=full", server.takeRequest().path)+ assertEquals(1, seasons.items.size)+ assertEquals(TraktCustomListItemIdentity(TraktCustomListItemType.SEASON, 1396, 2), seasons.items.single().identity)+ assertEquals("Example · Season 2", seasons.items.single().title)+ assertEquals(7001L, seasons.items.single().listItemId)+ val episodes = api.items("access", 88, TraktCustomListItemType.EPISODE, 1)+ assertEquals("/users/me/lists/88/items/episodes?page=1&limit=250&extended=full", server.takeRequest().path)+ assertEquals(TraktCustomListItemIdentity(TraktCustomListItemType.EPISODE, 1396, 2, 5), episodes.items.single().identity)+ assertEquals("Example · S2E5 · The Test", episodes.items.single().title)+ assertEquals(7002L, episodes.items.single().listItemId)+ }+ }++ @Test fun `ratings reads return only exact supported TMDB matches`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[+ {"type":"movie","rating":8,"movie":{"ids":{"tmdb":603}}},+ {"type":"movie","rating":7,"movie":{"ids":{"tmdb":null}}},+ {"type":"movie","rating":0,"movie":{"ids":{"tmdb":11}}}+ ]"""))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))++ val page = api.ratings("access", TraktRatingType.MOVIE, 1)+ val request = server.takeRequest()+ assertEquals("/users/me/ratings/movies?page=1&limit=100", request.path)+ assertEquals("Bearer access", request.getHeader("Authorization"))+ assertEquals(1, page.items.size)+ assertEquals(TraktRatingIdentity(TraktRatingType.MOVIE, 603L) to 8, page.items.single())+ assertEquals(2, page.skippedItems)+ }+ }++ @Test fun `ratings use the sync ratings endpoint and exact TMDB identity`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setResponseCode(201).setBody("{}"))+ server.enqueue(MockResponse().setResponseCode(201).setBody("{}"))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))++ api.setRating("access", TraktRatingIdentity(TraktRatingType.MOVIE, 603), 8)+ val movie = server.takeRequest()+ assertEquals("POST", movie.method)+ assertEquals("/sync/ratings", movie.path)+ assertEquals("Bearer access", movie.getHeader("Authorization"))+ val movieItem = Gson().fromJson(movie.body.readUtf8(), JsonObject::class.java)+ .getAsJsonArray("movies")[0].asJsonObject+ assertEquals(8, movieItem["rating"].asInt)+ assertEquals(603L, movieItem.getAsJsonObject("ids")["tmdb"].asLong)+ assertTrue(java.time.Instant.parse(movieItem["rated_at"].asString) != null)++ api.setRating("access", TraktRatingIdentity(TraktRatingType.SHOW, 1396), 10)+ val show = server.takeRequest()+ val showItem = Gson().fromJson(show.body.readUtf8(), JsonObject::class.java)+ .getAsJsonArray("shows")[0].asJsonObject+ assertEquals("/sync/ratings", show.path)+ assertEquals(10, showItem["rating"].asInt)+ assertEquals(1396L, showItem.getAsJsonObject("ids")["tmdb"].asLong)+ }+ }++ @Test fun `favorite writes use Trakt sync add and remove endpoints with TMDB ids`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setResponseCode(201).setBody("{}"))+ server.enqueue(MockResponse().setResponseCode(200).setBody("{}"))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))++ api.setFavorited("access", TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603), true)+ val add = server.takeRequest()+ assertEquals("POST", add.method)+ assertEquals("/sync/favorites", add.path)+ assertEquals("Bearer access", add.getHeader("Authorization"))+ val addBody = Gson().fromJson(add.body.readUtf8(), JsonObject::class.java)+ assertEquals(603L, addBody.getAsJsonArray("movies")[0].asJsonObject+ .getAsJsonObject("ids")["tmdb"].asLong)++ api.setFavorited("access", TraktFavoriteIdentity(TraktFavoriteType.SHOW, 1396), false)+ val remove = server.takeRequest()+ assertEquals("POST", remove.method)+ assertEquals("/sync/favorites/remove", remove.path)+ val removeBody = Gson().fromJson(remove.body.readUtf8(), JsonObject::class.java)+ assertEquals(1396L, removeBody.getAsJsonArray("shows")[0].asJsonObject+ .getAsJsonObject("ids")["tmdb"].asLong)+ }+ }++ @Test fun `exchange sends exact redirect and verifier without client secret`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""{"access_token":"test-access","refresh_token":"test-refresh","created_at":2000000,"expires_in":604800}"""))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))+ val result = api.exchange("code", "verifier")+ val request = server.takeRequest()+ assertEquals("/oauth/token", request.path)+ assertEquals("client", request.getHeader("trakt-api-key"))+ assertEquals("2", request.getHeader("trakt-api-version"))+ assertNull(request.getHeader("Authorization"))+ val body = Gson().fromJson(request.body.readUtf8(), JsonObject::class.java)+ assertFalse(body.has("client_secret"))+ assertEquals("verifier", body["code_verifier"].asString)+ assertEquals("https://example.com/oauth/trakt", body["redirect_uri"].asString)+ assertEquals("test-refresh", result.refreshToken)+ }+ }++ @Test fun `authenticated profile sends bearer and preserves OAuth error identifier`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""{"user":{"username":"viewer"}}"""))+ server.enqueue(MockResponse().setResponseCode(400).setBody("""{"error":"invalid_grant","error_description":"session not found"}"""))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))+ assertEquals("viewer", api.username("test-access"))+ assertEquals("Bearer test-access", server.takeRequest().getHeader("Authorization"))+ try { api.refresh("test-refresh"); fail("Expected failure") } catch (failure: TraktApiException) {+ assertEquals(400, failure.status)+ assertEquals("invalid_grant", failure.oauthError)+ assertFalse(failure.toString().contains("test-refresh"))+ }+ }+ }++ @Test fun `429 respects Retry After by suppressing further calls during cooldown`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setResponseCode(429).setHeader("Retry-After", "120"))+ val api = TraktApiClient(TraktConfig("client", "https://example.com/oauth/trakt"), OkHttpClient(), server.url("/"))+ repeat(2) {+ try { api.username("test-access"); fail("Expected rate limit") } catch (failure: TraktApiException) {+ assertEquals(429, failure.status)+ assertTrue(failure.retryAfterSeconds!! >= 119)+ }+ }+ assertEquals(1, server.requestCount)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktAuthServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktAuthServiceTest.ktnew file mode 100644index 00000000..7e8658fc--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktAuthServiceTest.kt@@ -0,0 +1,225 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktMessage+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavoriteWriteResult+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktRatingPage+import com.streamvault.domain.trakt.TraktRatingWriteResult+import kotlinx.coroutines.async+import kotlinx.coroutines.awaitAll+import kotlinx.coroutines.delay+import kotlinx.coroutines.runBlocking+import org.junit.Assert.*+import org.junit.Test+import java.net.URI+import java.net.URLDecoder++class TraktAuthServiceTest {+ private val config = TraktConfig("public-client", "https://streamvault.test/oauth/trakt/callback")+ private val now = 2000000L+ private fun tokens(access: String = "access", refresh: String = "refresh", created: Long = now) =+ TraktTokens(access, refresh, created, 604800)+ private class Store : TraktTokenStore {+ var session = TraktStoredSession()+ val writes = mutableListOf<TraktStoredSession>()+ override fun read() = session+ override fun write(session: TraktStoredSession) { this.session = session; writes += session }+ }+ private inner class Api : TraktApi, TraktFavoritesApi, TraktRatingsApi {+ var exchanges = 0+ var refreshes = 0+ var refreshFailure: Exception? = null+ var unauthorized = false+ val usedTokens = mutableListOf<String>()+ val favoriteWrites = mutableListOf<Triple<String, TraktFavoriteIdentity, Boolean>>()+ var favoriteFailure: Exception? = null+ val ratingWrites = mutableListOf<Triple<String, TraktRatingIdentity, Int>>()+ val ratingReads = mutableListOf<Triple<String, TraktRatingType, Int>>()+ override suspend fun exchange(code: String, verifier: String): TraktTokens {+ exchanges+++ assertEquals("authorization-code", code)+ assertEquals(43, verifier.length)+ return tokens()+ }+ override suspend fun refresh(refreshToken: String): TraktTokens {+ refreshes+++ assertEquals("refresh", refreshToken)+ delay(10)+ refreshFailure?.let { throw it }+ return tokens("new-access", "new-refresh")+ }+ override suspend fun username(accessToken: String): String {+ usedTokens += accessToken+ if (unauthorized) throw TraktApiException(401)+ return "viewer"+ }+ override suspend fun setFavorited(accessToken: String, identity: TraktFavoriteIdentity, favorited: Boolean) {+ favoriteFailure?.let { throw it }+ favoriteWrites += Triple(accessToken, identity, favorited)+ }+ override suspend fun setRating(accessToken: String, identity: TraktRatingIdentity, rating: Int) {+ ratingWrites += Triple(accessToken, identity, rating)+ }+ override suspend fun ratings(accessToken: String, type: TraktRatingType, page: Int): TraktRatingPage {+ ratingReads += Triple(accessToken, type, page)+ return TraktRatingPage(emptyList(), page, hasMore = false)+ }+ }+ private fun service(store: Store, api: Api) = TraktAuthService(config, store, api) { now }+ private fun parameters(url: String) = URI(url).rawQuery.split('&').associate {+ val pair = it.split('=', limit = 2)+ pair[0] to URLDecoder.decode(pair[1], "UTF-8")+ }+ private fun callback(state: String) = "${config.redirectUri}?code=authorization-code&state=$state"++ @Test fun `favorites source uses the connected account token`() = runBlocking {+ val store = Store().apply { session = TraktStoredSession(tokens()) }+ val api = Api()+ val service = service(store, api)+ service.load()++ val identity = TraktFavoriteIdentity(TraktFavoriteType.SHOW, 1396)+ assertEquals(TraktFavoriteWriteResult.Success, service.setFavorited(identity, true))+ assertEquals(listOf(Triple("access", identity, true)), api.favoriteWrites)+ }++ @Test fun `ratings source uses the connected account token`() = runBlocking {+ val store = Store().apply { session = TraktStoredSession(tokens()) }+ val api = Api()+ val service = service(store, api)+ service.load()++ val identity = TraktRatingIdentity(TraktRatingType.SHOW, 1396)+ assertEquals(TraktRatingWriteResult.Success, service.setRating(identity, 8))+ assertEquals(listOf(Triple("access", identity, 8)), api.ratingWrites)+ }++ @Test fun `ratings read uses connected account token`() = runBlocking {+ val store = Store().apply { session = TraktStoredSession(tokens()) }+ val api = Api()+ val service = service(store, api)+ service.load()++ assertTrue(service.ratings(TraktRatingType.MOVIE, 1) is com.streamvault.domain.trakt.TraktRatingPageResult.Success)+ assertEquals(listOf(Triple("access", TraktRatingType.MOVIE, 1)), api.ratingReads)+ }++ @Test fun `PKCE matches RFC 7636 S256 example`() {+ assertEquals("E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM",+ TraktPkce.challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"))+ }++ @Test fun `login uses fresh state and verifier and consumes callback once`() = runBlocking {+ val store = Store(); val api = Api(); val service = service(store, api)+ val first = parameters(service.beginSignIn())+ val firstVerifier = store.session.pending!!.verifier+ val second = parameters(service.beginSignIn())+ assertNotEquals(first["state"], second["state"])+ assertNotEquals(firstVerifier, store.session.pending!!.verifier)+ assertEquals("S256", second["code_challenge_method"])+ assertEquals(config.redirectUri, second["redirect_uri"])+ assertFalse(second.containsKey("client_secret"))+ val callback = callback(second.getValue("state"))+ service.completeSignIn(callback)+ service.completeSignIn(callback)+ assertEquals(1, api.exchanges)+ assertTrue(service.state.value.connected)+ assertEquals("viewer", service.state.value.username)+ assertNull(store.session.pending)+ }++ @Test fun `state mismatch expiry duplicate parameters and wrong path abort before token exchange`() = runBlocking {+ for (kind in listOf("state", "expired", "duplicate", "path")) {+ val store = Store(); val api = Api(); val service = service(store, api)+ val state = parameters(service.beginSignIn()).getValue("state")+ val pending = store.session.pending!!+ val callback = when (kind) {+ "state" -> callback("wrong")+ "expired" -> { store.session = TraktStoredSession(pending = TraktPendingLogin(pending.verifier, state, now - 601)); callback(state) }+ "duplicate" -> callback(state) + "&state=$state"+ else -> callback(state).replace("/callback", "/other")+ }+ service.completeSignIn(callback)+ assertEquals(kind, 0, api.exchanges)+ assertNull(store.session.pending)+ assertFalse(service.state.value.connected)+ assertEquals(TraktMessage.SIGN_IN_FAILED, service.state.value.message)+ }+ }++ @Test fun `browser denial is silent and pending login survives new service`() = runBlocking {+ val store = Store(); val api = Api()+ val state = parameters(service(store, api).beginSignIn()).getValue("state")+ val recreated = service(store, api)+ recreated.load()+ assertTrue(recreated.state.value.connecting)+ recreated.completeSignIn("${config.redirectUri}?error=access_denied&state=$state")+ assertNull(recreated.state.value.message)+ assertFalse(recreated.state.value.connecting)+ assertNull(store.session.pending)+ }++ @Test fun `concurrent requests rotate both tokens exactly once`() = runBlocking {+ val store = Store(); val api = Api(); val service = service(store, api)+ store.session = TraktStoredSession(tokens(created = now - 604800))+ List(8) { async { service.refreshProfile() } }.awaitAll()+ assertEquals(1, api.refreshes)+ assertEquals("new-access", store.session.tokens!!.accessToken)+ assertEquals("new-refresh", store.session.tokens!!.refreshToken)+ assertTrue(api.usedTokens.all { it == "new-access" })+ assertNull(store.writes.first().tokens) // Durable consumption marker before refresh.+ }++ @Test fun `invalid grant and ambiguous refresh failure never reuse old token`() = runBlocking {+ for (failure in listOf(TraktApiException(400, "invalid_grant"), java.io.IOException("network"))) {+ val store = Store(); val api = Api(); val service = service(store, api)+ store.session = TraktStoredSession(tokens(created = now - 604800))+ api.refreshFailure = failure+ service.refreshProfile(); service.refreshProfile()+ assertEquals(1, api.refreshes)+ assertNull(store.session.tokens)+ assertEquals(TraktMessage.RECONNECT_REQUIRED, service.state.value.message)+ assertFalse(service.state.value.connected)+ }+ }++ @Test fun `401 after one refresh clears session`() = runBlocking {+ val store = Store(); val api = Api(); val service = service(store, api)+ store.session = TraktStoredSession(tokens())+ api.unauthorized = true+ service.refreshProfile()+ assertEquals(1, api.refreshes)+ assertEquals(listOf("access", "new-access"), api.usedTokens)+ assertNull(store.session.tokens)+ assertEquals(TraktMessage.RECONNECT_REQUIRED, service.state.value.message)+ }++ @Test fun `explicit rate limit during refresh retains session for later retry`() = runBlocking {+ val store = Store(); val api = Api(); val service = service(store, api)+ store.session = TraktStoredSession(tokens(created = now - 604800))+ api.refreshFailure = TraktApiException(429, retryAfterSeconds = 120)+ service.refreshProfile()+ assertEquals("refresh", store.session.tokens!!.refreshToken)+ assertEquals(TraktMessage.RATE_LIMITED, service.state.value.message)+ assertTrue(service.state.value.connected)+ }++ @Test fun `disconnect clears pending login and prevents late callback reconnect`() = runBlocking {+ val store = Store(); val api = Api(); val service = service(store, api)+ val state = parameters(service.beginSignIn()).getValue("state")+ service.disconnect(); service.completeSignIn(callback(state))+ assertEquals(0, api.exchanges)+ assertFalse(service.state.value.connected)+ }++ @Test fun `configuration rejects insecure or ambiguous redirects`() {+ for (uri in listOf("", "streamvault://callback", "http://example.com/callback", "https://localhost/callback",+ "https://example.com/callback?x=1", "https://example.com/callback#fragment", "https://[email protected]/callback")) {+ assertFalse(uri, TraktConfig("client", uri).configured)+ }+ assertTrue(config.configured)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktCustomListsServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktCustomListsServiceTest.ktnew file mode 100644index 00000000..0758bc59--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktCustomListsServiceTest.kt@@ -0,0 +1,134 @@+package com.streamvault.data.trakt++import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktCustomList+import com.streamvault.domain.trakt.TraktCustomListItemType+import com.streamvault.domain.trakt.TraktCustomListItem+import com.streamvault.domain.trakt.TraktCustomListItemsPage+import com.streamvault.domain.trakt.TraktCustomListItemsPageResult+import com.streamvault.domain.trakt.TraktCustomListWriteResult+import com.streamvault.domain.trakt.TraktCustomListsPageResult+import com.streamvault.domain.trakt.TraktCustomListsSource+import com.streamvault.domain.trakt.TraktCustomListActionResult+import com.streamvault.domain.trakt.TraktCustomListRefreshResult+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Assert.assertFalse+import org.junit.Assert.assertTrue+import org.junit.Test+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever++class TraktCustomListsServiceTest {+ private class Account : TraktAccount {+ override val state = MutableStateFlow(TraktAccountState(configured = true, connected = true, username = "viewer"))+ override suspend fun load() = Unit+ override suspend fun beginSignIn() = error("Not used")+ override suspend fun completeSignIn(callback: String) = error("Not used")+ override suspend fun cancelSignIn() = Unit+ override suspend fun disconnect() = Unit+ override suspend fun refreshProfile() = Unit+ }++ private class Source : TraktCustomListsSource {+ var listsValue = listOf(+ TraktCustomList(1, "First", itemCount = 1),+ TraktCustomList(2, "Second", itemCount = 2),+ TraktCustomList(3, "Third", itemCount = 3),+ )+ var writeResult = TraktCustomListWriteResult.Success+ var itemsValue = emptyList<TraktCustomListItem>()+ val reordered = mutableListOf<List<Long>>()+ val reorderedItems = mutableListOf<Pair<Long, List<Long>>>()+ val deleted = mutableListOf<Long>()+ override suspend fun lists() = TraktCustomListsPageResult.Success(listsValue)+ override suspend fun items(listId: Long, type: TraktCustomListItemType, page: Int) =+ TraktCustomListItemsPageResult.Success(TraktCustomListItemsPage(+ itemsValue.filter { it.identity.type == type }, page, hasMore = false,+ ))+ override suspend fun createList(name: String, description: String?) = writeResult+ override suspend fun deleteList(listId: Long): TraktCustomListWriteResult {+ deleted += listId+ return writeResult+ }+ override suspend fun reorderLists(listIds: List<Long>): TraktCustomListWriteResult {+ reordered += listIds+ return writeResult+ }+ override suspend fun reorderItems(listId: Long, listItemIds: List<Long>): TraktCustomListWriteResult {+ reorderedItems += listId to listItemIds+ return writeResult+ }+ override suspend fun setItem(+ listId: Long,+ identity: com.streamvault.domain.trakt.TraktCustomListItemIdentity,+ included: Boolean,+ ) = writeResult+ }++ private fun service(account: Account, source: Source, incognito: Boolean = false): TraktCustomListsService {+ val history: PlaybackHistoryRepository = mock()+ runBlocking { whenever(history.isIncognitoModeEnabled()).thenReturn(incognito) }+ return TraktCustomListsService(account, source, history)+ }++ @Test fun `list reordering persists full order and updates visible state`() = runBlocking {+ val source = Source()+ val service = service(Account(), source)+ assertTrue(service.refreshLists(force = true) is TraktCustomListRefreshResult.Success)++ assertEquals(TraktCustomListActionResult.Success, service.reorderLists(listOf(3, 1, 2)))+ assertEquals(listOf(3L, 1L, 2L), source.reordered.single())+ assertEquals(listOf(3L, 1L, 2L), service.state.value.lists.map { it.id })+ }++ @Test fun `delete removes only the selected list and its cached contents`() = runBlocking {+ val source = Source()+ val service = service(Account(), source)+ assertTrue(service.refreshLists(force = true) is TraktCustomListRefreshResult.Success)+ assertTrue(service.refreshItems(2, force = true).isSuccess())++ assertEquals(TraktCustomListActionResult.Success, service.deleteList(2))+ assertEquals(listOf(2L), source.deleted)+ assertEquals(listOf(1L, 3L), service.state.value.lists.map { it.id })+ assertFalse(2L in service.state.value.itemsByList)+ }++ @Test fun `items can be reordered when the complete list has Trakt entry ids`() = runBlocking {+ val source = Source()+ val service = service(Account(), source)+ assertTrue(service.refreshLists(force = true) is TraktCustomListRefreshResult.Success)+ val first = TraktCustomListItem(+ com.streamvault.domain.trakt.TraktCustomListItemIdentity(TraktCustomListItemType.MOVIE, 603),+ "A", rank = 1, listItemId = 71,+ )+ val second = TraktCustomListItem(+ com.streamvault.domain.trakt.TraktCustomListItemIdentity(TraktCustomListItemType.SHOW, 1396),+ "B", rank = 2, listItemId = 72,+ )+ source.itemsValue = listOf(first, second)+ assertTrue(service.refreshItems(1, force = true).isSuccess())++ assertEquals(TraktCustomListActionResult.Success, service.reorderItems(1, listOf(second, first)))+ assertEquals(1L to listOf(72L, 71L), source.reorderedItems.single())+ assertEquals(listOf(second.identity, first.identity), service.state.value.itemsByList.getValue(1).map { it.identity })+ }++ @Test fun `incognito mode blocks deleting and reordering personal lists`() = runBlocking {+ val source = Source()+ val service = service(Account(), source, incognito = true)++ assertEquals(TraktCustomListActionResult.Failure(com.streamvault.domain.trakt.TraktCustomListsFailure.INCOGNITO),+ service.deleteList(1))+ assertEquals(TraktCustomListActionResult.Failure(com.streamvault.domain.trakt.TraktCustomListsFailure.INCOGNITO),+ service.reorderLists(listOf(1, 2, 3)))+ assertTrue(source.deleted.isEmpty())+ assertTrue(source.reordered.isEmpty())+ }++ private fun com.streamvault.domain.trakt.TraktCustomListItemsRefreshResult.isSuccess() =+ this is com.streamvault.domain.trakt.TraktCustomListItemsRefreshResult.Success+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktDiscoveryApiTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktDiscoveryApiTest.ktnew file mode 100644index 00000000..373fd82e--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktDiscoveryApiTest.kt@@ -0,0 +1,68 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktDiscoveryCategory+import com.streamvault.domain.trakt.TraktDiscoveryKind+import com.streamvault.domain.trakt.TraktDiscoveryMedia+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.assertEquals+import org.junit.Assert.assertFalse+import org.junit.Assert.assertNull+import org.junit.Assert.assertTrue+import org.junit.Test++class TraktDiscoveryApiTest {+ private fun api(server: MockWebServer) = TraktApiClient(+ TraktConfig("client", "https://example.org/callback"), OkHttpClient(), server.url("/")+ )++ @Test fun `trending movie wrappers and bare popular show rows preserve order and use public endpoints`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[+ {"watchers":20,"movie":{"title":"First","ids":{"tmdb":603}}},+ {"watchers":8,"movie":{"title":"Second","ids":{"tmdb":550}}}+ ]"""))+ server.enqueue(MockResponse().setBody("""[+ {"title":"Show A","ids":{"tmdb":1396}},+ {"title":"Show B","ids":{"tmdb":4607}}+ ]"""))+ val api = api(server)++ val trending = api.discover(+ TraktDiscoveryCategory(TraktDiscoveryMedia.MOVIE, TraktDiscoveryKind.TRENDING), 1+ )+ val popular = api.discover(+ TraktDiscoveryCategory(TraktDiscoveryMedia.SHOW, TraktDiscoveryKind.POPULAR), 1+ )++ assertEquals(listOf(603L, 550L), trending.tmdbIds)+ assertEquals(listOf(1396L, 4607L), popular.tmdbIds)+ assertEquals("/movies/trending?page=1&limit=100", server.takeRequest().path)+ val popularRequest = server.takeRequest()+ assertEquals("/shows/popular?page=1&limit=100", popularRequest.path)+ assertEquals("client", popularRequest.getHeader("trakt-api-key"))+ assertNull(popularRequest.getHeader("Authorization"))+ }+ }++ @Test fun `invalid and duplicate ids are skipped or deduplicated without losing Trakt rank`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[+ {"movie":{"ids":{"tmdb":603}}},+ {"movie":{"ids":{"tmdb":603}}},+ {"movie":{"ids":{"tmdb":603.5}}},+ {"movie":{"ids":{"trakt":2}}},+ {"movie":{"ids":{"tmdb":-5}}}+ ]"""))++ val page = api(server).discover(+ TraktDiscoveryCategory(TraktDiscoveryMedia.MOVIE, TraktDiscoveryKind.TRENDING), 1+ )++ assertEquals(listOf(603L), page.tmdbIds)+ assertEquals(3, page.skippedItems)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktDiscoveryServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktDiscoveryServiceTest.ktnew file mode 100644index 00000000..c32b34d8--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktDiscoveryServiceTest.kt@@ -0,0 +1,59 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktDiscoveryCategory+import com.streamvault.domain.trakt.TraktDiscoveryKind+import com.streamvault.domain.trakt.TraktDiscoveryMedia+import com.streamvault.domain.trakt.TraktDiscoveryPage+import com.streamvault.domain.trakt.TraktDiscoveryRefreshResult+import com.streamvault.domain.trakt.TraktDiscoverySource+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Assert.assertFalse+import org.junit.Assert.assertTrue+import org.junit.Test++class TraktDiscoveryServiceTest {+ private class Source : TraktDiscoverySource {+ var page = TraktDiscoveryPage(emptyList())+ var shouldFail = false+ var reads = 0++ override suspend fun discover(category: TraktDiscoveryCategory, page: Int): TraktDiscoveryPage {+ reads+++ assertEquals(1, page)+ if (shouldFail) error("offline")+ return this.page+ }+ }++ @Test fun `successful discovery pages are sanitized and cached until forced`() = runBlocking {+ val source = Source().apply { page = TraktDiscoveryPage(listOf(603, 603, -1, 550), skippedItems = 2) }+ val service = TraktDiscoveryService(source)+ val category = TraktDiscoveryCategory(TraktDiscoveryMedia.MOVIE, TraktDiscoveryKind.TRENDING)++ assertEquals(TraktDiscoveryRefreshResult.Success(2, skipped = 2), service.refresh(category))+ assertEquals(listOf(603L, 550L), service.state.value.items(category))+ assertTrue(service.state.value.isLoaded(category))+ assertEquals(TraktDiscoveryRefreshResult.Success(2), service.refresh(category))+ assertEquals(1, source.reads)++ source.page = TraktDiscoveryPage(listOf(550, 603))+ service.refresh(category, force = true)+ assertEquals(listOf(550L, 603L), service.state.value.items(category))+ assertEquals(2, source.reads)+ }++ @Test fun `failed refresh keeps a previous good page and marks the category failed`() = runBlocking {+ val source = Source().apply { page = TraktDiscoveryPage(listOf(603, 550)) }+ val service = TraktDiscoveryService(source)+ val category = TraktDiscoveryCategory(TraktDiscoveryMedia.MOVIE, TraktDiscoveryKind.POPULAR)+ service.refresh(category)+ source.shouldFail = true++ assertEquals(TraktDiscoveryRefreshResult.Failure, service.refresh(category, force = true))+ assertEquals(listOf(603L, 550L), service.state.value.items(category))+ assertTrue(service.state.value.isLoaded(category))+ assertTrue(category in service.state.value.failed)+ assertFalse(category in service.state.value.refreshing)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktFavoriteImporterServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktFavoriteImporterServiceTest.ktnew file mode 100644index 00000000..d0bb13b6--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktFavoriteImporterServiceTest.kt@@ -0,0 +1,77 @@+package com.streamvault.data.trakt++import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.Series+import com.streamvault.domain.repository.FavoriteRepository+import com.streamvault.domain.repository.MovieRepository+import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.repository.ProviderRepository+import com.streamvault.domain.repository.SeriesRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoritePage+import com.streamvault.domain.trakt.TraktFavoritePageResult+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavoritesSource+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.flowOf+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Test+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever++class TraktFavoriteImporterServiceTest {+ private class Account : TraktAccount {+ override val state = MutableStateFlow(TraktAccountState(configured = true, connected = true, username = "viewer"))+ override suspend fun load() = Unit+ override suspend fun beginSignIn() = error("unused")+ override suspend fun completeSignIn(callback: String) = Unit+ override suspend fun cancelSignIn() = Unit+ override suspend fun disconnect() = Unit+ override suspend fun refreshProfile() = Unit+ }++ @Test fun `imports exact provider matches and reports already present and unmatched`() = runBlocking {+ val provider = LegacyProvider(id = 7, name = "Provider", type = ProviderType.M3U, serverUrl = "https://example.org")+ val providers = mock<ProviderRepository>()+ whenever(providers.getActiveProvider()).thenReturn(flowOf(provider))+ val movies = mock<MovieRepository>()+ whenever(movies.getMoviesByTmdbIds(7, listOf(603L, 999L))).thenReturn(+ listOf(Movie(id = 10, name = "Fight Club", tmdbId = 603, providerId = 7)))+ val series = mock<SeriesRepository>()+ whenever(series.getSeriesByTmdbIds(7, listOf(1396L))).thenReturn(+ listOf(Series(id = 20, name = "Breaking Bad", tmdbId = 1396, providerId = 7)))+ val history = mock<PlaybackHistoryRepository>()+ whenever(history.isIncognitoModeEnabled()).thenReturn(false)+ val favorites = mock<FavoriteRepository>()+ whenever(favorites.isFavorite(7, 10, ContentType.MOVIE)).thenReturn(true)+ whenever(favorites.isFavorite(7, 20, ContentType.SERIES)).thenReturn(false)+ whenever(favorites.addFavorite(7, 20, ContentType.SERIES, null)).thenReturn(Result.success(Unit))+ val source = object : TraktFavoritesSource {+ override suspend fun favorites(type: TraktFavoriteType, page: Int): TraktFavoritePageResult =+ TraktFavoritePageResult.Success(TraktFavoritePage(+ identities = if (type == TraktFavoriteType.MOVIE) listOf(+ TraktFavoriteIdentity(type, 603), TraktFavoriteIdentity(type, 999),+ ) else listOf(TraktFavoriteIdentity(type, 1396)),+ page = page,+ hasMore = false,+ ))+ override suspend fun setFavorited(+ identity: TraktFavoriteIdentity,+ favorited: Boolean,+ ) = com.streamvault.domain.trakt.TraktFavoriteWriteResult.Success+ }++ val result = TraktFavoriteImporterService(Account(), source, history, providers, movies, series, favorites)+ .importToLocal()++ assertEquals(com.streamvault.domain.trakt.TraktFavoriteImportResult.Success(+ imported = 1, alreadyPresent = 1, unmatched = 1, skipped = 0), result)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktFavoritesApiTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktFavoritesApiTest.ktnew file mode 100644index 00000000..32a170a6--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktFavoritesApiTest.kt@@ -0,0 +1,39 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.assertEquals+import org.junit.Assert.assertTrue+import org.junit.Test++class TraktFavoritesApiTest {+ private fun api(server: MockWebServer) = TraktApiClient(+ TraktConfig("client", "https://example.org/callback"), OkHttpClient(), server.url("/"))++ @Test fun `favorites pages parse exact movie and show TMDB ids`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setHeader("X-Pagination-Page-Count", "2").setBody("""[+ {"rank":1,"movie":{"title":"Movie","ids":{"tmdb":603}}},+ {"rank":2,"movie":{"title":"Missing id","ids":{"trakt":2}}}+ ]"""))+ server.enqueue(MockResponse().setBody("""[+ {"rank":1,"show":{"title":"Show","ids":{"tmdb":1396}}}+ ]"""))+ val api = api(server)++ val movies = api.favorites("token", TraktFavoriteType.MOVIE, 1)+ val shows = api.favorites("token", TraktFavoriteType.SHOW, 1)++ assertEquals(listOf(TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603)), movies.identities)+ assertEquals(1, movies.skippedItems)+ assertTrue(movies.hasMore)+ assertEquals(listOf(TraktFavoriteIdentity(TraktFavoriteType.SHOW, 1396)), shows.identities)+ assertEquals("/sync/favorites/movies?page=1&limit=100", server.takeRequest().path)+ assertEquals("/sync/favorites/shows?page=1&limit=100", server.takeRequest().path)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktFavoritesServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktFavoritesServiceTest.ktnew file mode 100644index 00000000..926d6602--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktFavoritesServiceTest.kt@@ -0,0 +1,107 @@+package com.streamvault.data.trakt++import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavoriteWriteResult+import com.streamvault.domain.trakt.TraktFavoritesSource+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Assert.assertTrue+import org.junit.Test+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever++class TraktFavoritesServiceTest {+ private class Account(connected: Boolean = true) : TraktAccount {+ val mutableState = MutableStateFlow(+ TraktAccountState(configured = true, connected = connected, username = if (connected) "viewer" else null),+ )+ override val state = mutableState+ override suspend fun load() = Unit+ override suspend fun beginSignIn() = error("Not used")+ override suspend fun completeSignIn(callback: String) = error("Not used")+ override suspend fun cancelSignIn() = Unit+ override suspend fun disconnect() { mutableState.value = mutableState.value.copy(connected = false, username = null) }+ override suspend fun refreshProfile() = Unit+ }++ private class Source : TraktFavoritesSource {+ val writes = mutableListOf<Pair<TraktFavoriteIdentity, Boolean>>()+ var result: TraktFavoriteWriteResult = TraktFavoriteWriteResult.Success+ var afterWrite: (() -> Unit)? = null++ override suspend fun setFavorited(identity: TraktFavoriteIdentity, favorited: Boolean): TraktFavoriteWriteResult {+ writes += identity to favorited+ afterWrite?.invoke()+ return result+ }+ }++ private fun service(account: Account, source: Source, incognito: Boolean = false): TraktFavoritesService {+ val history: PlaybackHistoryRepository = mock()+ runBlocking { whenever(history.isIncognitoModeEnabled()).thenReturn(incognito) }+ return TraktFavoritesService(account, source, history)+ }++ @Test fun `writes the requested movie and show state`() = runBlocking {+ val source = Source()+ val service = service(Account(), source)+ val movie = TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603)+ val show = TraktFavoriteIdentity(TraktFavoriteType.SHOW, 1396)++ assertEquals(TraktFavoriteActionResult.Success, service.setFavorited(movie, true))+ assertEquals(TraktFavoriteActionResult.Success, service.setFavorited(show, false))+ assertEquals(listOf(movie to true, show to false), source.writes)+ }++ @Test fun `disconnected account does not send a write`() = runBlocking {+ val source = Source()+ val service = service(Account(connected = false), source)++ assertEquals(+ TraktFavoriteActionResult.Failure(TraktFavoriteFailure.DISCONNECTED),+ service.setFavorited(TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603), true),+ )+ assertTrue(source.writes.isEmpty())+ }++ @Test fun `incognito prevents writes`() = runBlocking {+ val source = Source()+ val service = service(Account(), source, incognito = true)++ assertEquals(+ TraktFavoriteActionResult.Failure(TraktFavoriteFailure.INCOGNITO),+ service.setFavorited(TraktFavoriteIdentity(TraktFavoriteType.SHOW, 1396), true),+ )+ assertTrue(source.writes.isEmpty())+ }++ @Test fun `failed remote write reports failure without claiming success`() = runBlocking {+ val source = Source().apply { result = TraktFavoriteWriteResult.Failed }+ val service = service(Account(), source)++ assertEquals(+ TraktFavoriteActionResult.Failure(TraktFavoriteFailure.REQUEST_FAILED),+ service.setFavorited(TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603), true),+ )+ }++ @Test fun `account change during write is reported`() = runBlocking {+ val account = Account()+ val source = Source().apply {+ afterWrite = { account.mutableState.value = account.mutableState.value.copy(username = "other") }+ }+ val service = service(account, source)++ assertEquals(+ TraktFavoriteActionResult.Failure(TraktFavoriteFailure.ACCOUNT_CHANGED),+ service.setFavorited(TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603), true),+ )+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktHistoryApiTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryApiTest.ktnew file mode 100644index 00000000..1ffb2ad2--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryApiTest.kt@@ -0,0 +1,62 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.*+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.*+import org.junit.Test+import java.time.Instant++class TraktHistoryApiTest {+ private fun api(server: MockWebServer) = TraktApiClient(+ TraktConfig("client", "https://example.org/callback"), OkHttpClient(), server.url("/"))+ @Test fun `mixed history uses exact IDs timestamps headers and pagination`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setHeader("X-Pagination-Page-Count", "3").setBody("""[+ {"id":9007199254740993,"type":"movie","watched_at":"2026-10-11T12:00:00Z","movie":{"ids":{"tmdb":603}}},+ {"id":2,"type":"episode","watched_at":"2026-10-11T12:30:00Z","show":{"ids":{"tmdb":1396}},"episode":{"season":0,"number":3}},+ {"id":3,"type":"movie","watched_at":"bad-date","movie":{"ids":{"tmdb":603}}},+ {"id":4,"type":"movie","watched_at":"2026-10-11T12:00:00Z","movie":{"title":"The Matrix"}}+ ]"""))+ val page = api(server).history("test-access", 2)+ assertEquals(2, page.page)+ assertTrue(page.hasMore)+ assertEquals(2, page.skippedEntries)+ assertEquals(9007199254740993L, page.entries[0].historyId)+ assertEquals(TraktMediaIdentity.MovieId(603), page.entries[0].media)+ assertEquals(Instant.parse("2026-10-11T12:00:00Z").toEpochMilli(), page.entries[0].watchedAtMs)+ assertEquals(TraktMediaIdentity.EpisodeId(1396, 0, 3), page.entries[1].media)+ val request = server.takeRequest()+ assertEquals("/sync/history?page=2&limit=100", request.path)+ assertEquals("GET", request.method)+ assertEquals("Bearer test-access", request.getHeader("Authorization"))+ assertEquals("client", request.getHeader("trakt-api-key"))+ }+ }++ @Test fun `missing pagination header uses raw row count even if every row is skipped`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody(List(100) { "{}" }.joinToString(",", "[", "]")))+ server.enqueue(MockResponse().setBody("[]"))+ val api = api(server)+ val first = api.history("test-access", 1)+ assertTrue(first.hasMore)+ assertEquals(100, first.skippedEntries)+ assertFalse(api.history("test-access", 2).hasMore)+ }+ }++ @Test fun `fractional IDs and episode numbers are not truncated into another media identity`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[+ {"id":1,"type":"movie","watched_at":"2026-10-11T12:00:00Z","movie":{"ids":{"tmdb":603.5}}},+ {"id":2,"type":"episode","watched_at":"2026-10-11T12:00:00Z","show":{"ids":{"tmdb":1396}},"episode":{"season":2,"number":3.5}}+ ]"""))+ val page = api(server).history("test-access", 1)+ assertTrue(page.entries.isEmpty())+ assertEquals(2, page.skippedEntries)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktHistoryAuthTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryAuthTest.ktnew file mode 100644index 00000000..296d0f78--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryAuthTest.kt@@ -0,0 +1,87 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.*+import kotlinx.coroutines.*+import org.junit.Assert.*+import org.junit.Test++class TraktHistoryAuthTest {+ private class Store(var session: TraktStoredSession) : TraktTokenStore {+ override fun read() = session+ override fun write(session: TraktStoredSession) { this.session = session }+ }+ private class Api : TraktApi, TraktPlaybackApi, TraktHistoryApi {+ var refreshes = 0+ val reads = mutableListOf<String>()+ val writes = mutableListOf<String>()+ var rejectOld = false+ var failure: TraktApiException? = null+ override suspend fun exchange(code: String, verifier: String) = error("Not used")+ override suspend fun refresh(refreshToken: String): TraktTokens {+ refreshes+++ delay(10)+ return TraktTokens("new-access", "new-refresh", 1000, 1000)+ }+ override suspend fun username(accessToken: String) = "viewer"+ override suspend fun scrobble(accessToken: String, event: TraktScrobbleEvent): Boolean {+ writes += accessToken+ return true+ }+ override suspend fun history(accessToken: String, page: Int): TraktHistoryPage {+ reads += accessToken+ failure?.let { throw it }+ if (rejectOld && accessToken == "old-access") throw TraktApiException(401)+ return TraktHistoryPage(emptyList(), page, false)+ }+ override suspend fun upload(accessToken: String,+ events: List<TraktHistoryUpload>): TraktHistoryUploadResult = TraktHistoryUploadResult.Success(events.size)+ }+ private fun tokens(expired: Boolean = false) = TraktTokens("old-access", "old-refresh", if (expired) 1 else 1000, 1000)+ private fun service(store: Store, api: Api) = TraktAuthService(+ TraktConfig("client", "https://example.org/callback"), store, api, now = { 1000 })++ @Test fun `history reads and playback writes share one rotating token lock`() = runBlocking {+ val api = Api()+ val store = Store(TraktStoredSession(tokens(true)))+ val service = service(store, api)+ coroutineScope {+ val read = async { service.history(1) }+ val write = async { service.send(TraktScrobbleEvent(TraktMediaIdentity.MovieId(603), TraktScrobbleAction.START, 10.0)) }+ assertTrue(read.await() is TraktHistoryResult.Success)+ assertEquals(TraktScrobbleOutcome.SENT, write.await())+ }+ assertEquals(1, api.refreshes)+ assertEquals(listOf("new-access"), api.reads)+ assertEquals(listOf("new-access"), api.writes)+ assertTrue(store.read().tokens?.refreshToken == "new-refresh")+ }++ @Test fun `explicit history unauthorized response refreshes once`() = runBlocking {+ val api = Api().apply { rejectOld = true }+ val result = service(Store(TraktStoredSession(tokens())), api).history(2)+ assertEquals(2, (result as TraktHistoryResult.Success).history.page)+ assertEquals(listOf("old-access", "new-access"), api.reads)+ assertEquals(1, api.refreshes)+ }++ @Test fun `second unauthorized history response clears tokens and requests reconnect`() = runBlocking {+ val api = Api().apply { failure = TraktApiException(401) }+ val store = Store(TraktStoredSession(tokens()))+ assertEquals(TraktHistoryResult.Failure(TraktMessage.RECONNECT_REQUIRED), service(store, api).history(1))+ assertNull(store.read().tokens)+ assertEquals(2, api.reads.size)+ assertEquals(1, api.refreshes)+ }++ @Test fun `disconnected and rate limited reads do not retry`() = runBlocking {+ val api = Api()+ assertEquals(TraktHistoryResult.Disconnected, service(Store(TraktStoredSession()), api).history(1))+ assertTrue(api.reads.isEmpty())+ api.failure = TraktApiException(429)+ val store = Store(TraktStoredSession(tokens()))+ assertEquals(TraktHistoryResult.Failure(TraktMessage.RATE_LIMITED), service(store, api).history(1))+ assertEquals(1, api.reads.size)+ assertEquals(0, api.refreshes)+ assertNotNull(store.read().tokens)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktHistoryImportDaoTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryImportDaoTest.ktnew file mode 100644index 00000000..b4dd149e--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryImportDaoTest.kt@@ -0,0 +1,74 @@+package com.streamvault.data.trakt++import androidx.room.Room+import com.streamvault.data.local.StreamVaultDatabase+import com.streamvault.data.local.RoomDatabaseTransactionRunner+import com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.data.mapper.toEntity+import com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.repository.PlaybackHistoryRepositoryImpl+import com.streamvault.domain.model.*+import com.streamvault.domain.trakt.*+import kotlinx.coroutines.flow.flowOf+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.runBlocking+import org.junit.After+import org.junit.Before+import org.junit.Test+import org.junit.Assert.*+import org.junit.runner.RunWith+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever+import org.robolectric.RobolectricTestRunner+import org.robolectric.RuntimeEnvironment++@RunWith(RobolectricTestRunner::class)+class TraktHistoryImportDaoTest {+ private lateinit var database: StreamVaultDatabase+ @Before fun setup() {+ database = Room.inMemoryDatabaseBuilder(RuntimeEnvironment.getApplication(), StreamVaultDatabase::class.java)+ .allowMainThreadQueries().build()+ }+ @After fun close() { database.close() }+ private fun repository(): PlaybackHistoryRepositoryImpl {+ val preferences = mock<PreferencesRepository>()+ whenever(preferences.isIncognitoMode).thenReturn(flowOf(false))+ return PlaybackHistoryRepositoryImpl(database.playbackHistoryDao(), preferences,+ database.movieDao(), database.episodeDao(), RoomDatabaseTransactionRunner(database))+ }+ private suspend fun provider() {+ database.providerDao().insert(ProviderEntity(id = 1, name = "Synthetic", type = ProviderType.M3U,+ serverUrl = "https://example.org"))+ }+ @Test fun completedImportPersistsOnceAndUpdatesMovieProjection() = runBlocking {+ provider()+ database.movieDao().insertAll(listOf(Movie(id = 10, providerId = 1, name = "Movie", tmdbId = 603,+ durationSeconds = 100).toEntity()))+ val repository = repository()+ val base = PlaybackHistory(contentId = 10, contentType = ContentType.MOVIE, providerId = 1,+ title = "Movie", streamUrl = "", totalDurationMs = 100000)+ val identity = TraktMediaIdentity.MovieId(603)+ val match = TraktHistoryMatch(identity, 5000, 3)+ assertEquals(true, repository.importTraktHistory(base, identity, match).getOrNull())+ assertEquals(false, repository.importTraktHistory(base, identity, match).getOrNull())+ val row = requireNotNull(database.playbackHistoryDao().get(10, ContentType.MOVIE.name, 1))+ assertEquals("COMPLETED_AUTO", row.watchedStatus)+ assertEquals(5000L, row.lastWatchedAt)+ assertEquals(3, row.watchCount)+ assertEquals(100000L, row.resumePositionMs)+ assertEquals(1, database.playbackHistoryDao().getAllSync().size)+ assertEquals(100000L, database.movieDao().getByProviderAndTmdbIdSync(1, 603).single().watchProgress)+ }+ @Test fun unknownDurationCompletedEpisodeIsExcludedFromUnwatchedCount() = runBlocking {+ provider()+ database.seriesDao().insertAll(listOf(Series(id = 42, providerId = 1, name = "Show", tmdbId = 1396).toEntity()))+ database.episodeDao().insertAll(listOf(+ Episode(id = 20, title = "Watched", providerId = 1, seriesId = 42, seasonNumber = 1, episodeNumber = 1).toEntity(),+ Episode(id = 21, title = "Unwatched", providerId = 1, seriesId = 42, seasonNumber = 1, episodeNumber = 2).toEntity()))+ val base = PlaybackHistory(contentId = 20, contentType = ContentType.SERIES_EPISODE, providerId = 1,+ title = "Watched", streamUrl = "", seriesId = 42, seasonNumber = 1, episodeNumber = 1)+ val identity = TraktMediaIdentity.EpisodeId(1396, 1, 1)+ assertEquals(true, repository().importTraktHistory(base, identity, TraktHistoryMatch(identity, 5000, 1)).getOrNull())+ assertEquals(1, database.episodeDao().getUnwatchedCount(1, 42, .95f).first())+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktHistorySyncServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktHistorySyncServiceTest.ktnew file mode 100644index 00000000..c9d67e6e--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktHistorySyncServiceTest.kt@@ -0,0 +1,92 @@+package com.streamvault.data.trakt++import com.streamvault.data.local.dao.*+import com.streamvault.data.mapper.toEntity+import com.streamvault.domain.model.*+import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.*+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.flowOf+import kotlinx.coroutines.runBlocking+import org.junit.Assert.*+import org.junit.Test+import org.mockito.kotlin.*++class TraktHistorySyncServiceTest {+ private val account = mock<TraktAccount>()+ private val state = MutableStateFlow(TraktAccountState(configured = true, connected = true, username = "viewer"))+ private val source = mock<TraktHistorySource>()+ private val movies = mock<MovieDao>()+ private val series = mock<SeriesDao>()+ private val episodes = mock<EpisodeDao>()+ private val history = mock<PlaybackHistoryRepository>()+ private val identity = TraktMediaIdentity.MovieId(603)+ init {+ whenever(account.state).thenReturn(state)+ whenever(history.getRecentlyWatched(5001)).thenReturn(flowOf(emptyList()))+ runBlocking { whenever(history.isIncognitoModeEnabled()).thenReturn(false) }+ }+ private fun service() = TraktHistorySyncService(account, source, movies, series, episodes, history)+ private fun page(number: Int = 1, more: Boolean = false) = TraktHistoryResult.Success(+ TraktHistoryPage(listOf(TraktHistoryEntry(1, identity, 2000)), number, more))++ @Test fun `all pages stage before writes and duplicate history IDs are not extra plays`() = runBlocking {+ whenever(source.history(1)).thenReturn(page(1, true))+ whenever(source.history(2)).thenReturn(page(2))+ whenever(movies.getByTmdbIdsSync(listOf(603))).thenReturn(listOf(Movie(id = 10, providerId = 5, name = "Movie", tmdbId = 603).toEntity().copy(watchCount = 4)))+ whenever(history.importTraktHistory(any(), eq(identity), any())).thenReturn(Result.success(true))+ assertEquals(TraktHistorySyncResult.Success(1, 0, 0, 0), service().sync())+ val order = inOrder(source, history)+ order.verify(source).history(1)+ order.verify(source).history(2)+ order.verify(history).importTraktHistory(check { assertEquals(4, it.watchCount) }, eq(identity), check { assertEquals(1, it.playCount) })+ Unit+ }++ @Test fun `failed later page applies nothing`() = runBlocking {+ whenever(source.history(1)).thenReturn(page(1, true))+ whenever(source.history(2)).thenReturn(TraktHistoryResult.Failure(TraktMessage.NETWORK_ERROR))+ assertEquals(TraktHistorySyncResult.Failure(TraktSyncFailure.READ_FAILED), service().sync())+ verify(history).isIncognitoModeEnabled()+ verify(history, never()).importTraktHistory(any(), any(), any())+ verify(source, never()).upload(any(), any())+ verifyNoInteractions(movies, series, episodes)+ }++ @Test fun `page limit never applies a partial snapshot`() = runBlocking {+ whenever(source.history(any())).thenAnswer {+ page(it.getArgument(0), true)+ }+ assertEquals(TraktHistorySyncResult.Failure(TraktSyncFailure.READ_LIMIT), service().sync())+ verify(source, times(50)).history(any())+ verify(history).isIncognitoModeEnabled()+ verify(history, never()).importTraktHistory(any(), any(), any())+ verify(source, never()).upload(any(), any())+ verifyNoInteractions(movies, series, episodes)+ }++ @Test fun `account switch after reading aborts before catalog or history access`() = runBlocking {+ whenever(source.history(1)).thenAnswer {+ state.value = state.value.copy(username = "another-viewer")+ page()+ }+ assertEquals(TraktHistorySyncResult.Failure(TraktSyncFailure.ACCOUNT_CHANGED), service().sync())+ verify(history).isIncognitoModeEnabled()+ verify(history, never()).importTraktHistory(any(), any(), any())+ verifyNoInteractions(movies, series, episodes)+ }++ @Test fun `episodes match cached show IDs and exact ownership without provider network calls`() = runBlocking {+ val episodeIdentity = TraktMediaIdentity.EpisodeId(1396, 2, 3)+ whenever(source.history(1)).thenReturn(TraktHistoryResult.Success(+ TraktHistoryPage(listOf(TraktHistoryEntry(1, episodeIdentity, 2000)), 1, false)))+ whenever(series.getByTmdbIdsSync(listOf(1396))).thenReturn(listOf(Series(id = 42, name = "Show", tmdbId = 1396, providerId = 5).toEntity()))+ whenever(episodes.getEntitiesBySeriesSync(42)).thenReturn(listOf(+ Episode(id = 10, title = "Matched", seasonNumber = 2, episodeNumber = 3, seriesId = 42, providerId = 5).toEntity(),+ Episode(id = 11, title = "Wrong provider", seasonNumber = 2, episodeNumber = 3, seriesId = 42, providerId = 6).toEntity()))+ whenever(history.importTraktHistory(any(), eq(episodeIdentity), any())).thenReturn(Result.success(true))+ assertEquals(TraktHistorySyncResult.Success(1, 0, 0, 0), service().sync())+ verify(history).importTraktHistory(check { assertEquals(10L, it.contentId) }, eq(episodeIdentity), any())+ Unit+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadApiTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadApiTest.ktnew file mode 100644index 00000000..7090a52f--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadApiTest.kt@@ -0,0 +1,64 @@+package com.streamvault.data.trakt++import com.google.gson.Gson+import com.google.gson.JsonObject+import com.streamvault.domain.trakt.TraktHistoryUpload+import com.streamvault.domain.trakt.TraktHistoryUploadResult+import com.streamvault.domain.trakt.TraktMediaIdentity+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.*+import org.junit.Test+import java.time.Instant++class TraktHistoryUploadApiTest {+ private fun api(server: MockWebServer) = TraktApiClient(+ TraktConfig("public-client", "https://example.org/callback"), OkHttpClient(), server.url("/"))++ @Test fun posts_canonical_movie_and_exact_episode_ids_and_counts_response() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[{"type":"show","show":{"ids":{"tmdb":1396,"trakt":902}}}]"""))+ server.enqueue(MockResponse().setBody("""{"season":2,"number":3,"ids":{"trakt":7003}}"""))+ server.enqueue(MockResponse().setBody("""{"added":{"movies":1,"episodes":0},"updated":{"movies":0,"episodes":1},"not_found":{"movies":[{}],"episodes":[]}}"""))+ val watchedAt = Instant.parse("2023-11-14T22:13:59.999Z").toEpochMilli()++ val result = api(server).upload("access-token", listOf(+ TraktHistoryUpload(TraktMediaIdentity.MovieId(603), watchedAt),+ TraktHistoryUpload(TraktMediaIdentity.EpisodeId(1396, 2, 3), watchedAt),+ ))++ assertEquals(TraktHistoryUploadResult.Success(uploaded = 2, unmatched = 1), result)+ val lookup = server.takeRequest()+ assertEquals("/search/tmdb/1396?type=show", lookup.path)+ assertEquals("Bearer access-token", lookup.getHeader("Authorization"))+ val episodeLookup = server.takeRequest()+ assertEquals("/shows/902/seasons/2/episodes/3", episodeLookup.path)+ val upload = server.takeRequest()+ assertEquals("/sync/history", upload.path)+ assertEquals("Bearer access-token", upload.getHeader("Authorization"))++ val payload = Gson().fromJson(upload.body.readUtf8(), JsonObject::class.java)+ val movie = payload.getAsJsonArray("movies").single().asJsonObject+ assertEquals("2023-11-14T22:13:00Z", movie["watched_at"].asString)+ assertEquals(603L, movie.getAsJsonObject("ids")["tmdb"].asLong)+ val episode = payload.getAsJsonArray("episodes").single().asJsonObject+ assertEquals("2023-11-14T22:13:00Z", episode["watched_at"].asString)+ assertEquals(7003L, episode.getAsJsonObject("ids")["trakt"].asLong)+ assertEquals(3, server.requestCount)+ }+ }++ @Test fun unresolved_episode_is_counted_without_posting_history() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("[]"))+ val result = api(server).upload("access-token", listOf(+ TraktHistoryUpload(TraktMediaIdentity.EpisodeId(1396, 2, 3), 1_700_000_000_000L)))++ assertEquals(TraktHistoryUploadResult.Success(uploaded = 0, unmatched = 1), result)+ assertEquals("/search/tmdb/1396?type=show", server.takeRequest().path)+ assertEquals(1, server.requestCount)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadAuthTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadAuthTest.ktnew file mode 100644index 00000000..779eafde--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadAuthTest.kt@@ -0,0 +1,89 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.*+import kotlinx.coroutines.runBlocking+import org.junit.Assert.*+import org.junit.Test++class TraktHistoryUploadAuthTest {+ private class Store(var session: TraktStoredSession) : TraktTokenStore {+ override fun read() = session+ override fun write(session: TraktStoredSession) { this.session = session }+ }++ private class Api : TraktApi, TraktHistoryApi {+ var refreshes = 0+ val uploads = mutableListOf<Pair<String, List<TraktHistoryUpload>>>()+ var rejectOld = false+ var unauthorized = false+ var failure: Exception? = null++ override suspend fun exchange(code: String, verifier: String) = error("Not used")+ override suspend fun refresh(refreshToken: String): TraktTokens {+ refreshes+++ return TraktTokens("new-access", "new-refresh", 1000, 1000)+ }+ override suspend fun username(accessToken: String) = "viewer"+ override suspend fun history(accessToken: String, page: Int) = TraktHistoryPage(emptyList(), page, false)+ override suspend fun upload(accessToken: String, events: List<TraktHistoryUpload>): TraktHistoryUploadResult {+ uploads += accessToken to events+ failure?.let { throw it }+ if (unauthorized || (rejectOld && accessToken == "old-access")) throw TraktApiException(401)+ return TraktHistoryUploadResult.Success(events.size)+ }+ }++ private val event = TraktHistoryUpload(TraktMediaIdentity.MovieId(603), 1_700_000_000_000L)+ private fun tokens() = TraktTokens("old-access", "old-refresh", 1000, 1000)+ private fun service(store: Store, api: Api) = TraktAuthService(+ TraktConfig("client", "https://example.org/callback"), store, api, now = { 1000 })++ @Test fun upload_rejects_a_different_account_before_calling_api() = runBlocking {+ val api = Api()+ val service = service(Store(TraktStoredSession(tokens())), api)+ service.load()++ assertEquals(TraktHistoryUploadResult.Disconnected, service.upload("another-viewer", listOf(event)))+ assertTrue(api.uploads.isEmpty())+ assertEquals(0, api.refreshes)+ }++ @Test fun explicit_unauthorized_upload_refreshes_once_and_retries_with_new_token() = runBlocking {+ val api = Api().apply { rejectOld = true }+ val store = Store(TraktStoredSession(tokens()))+ val service = service(store, api)+ service.load()++ assertEquals(TraktHistoryUploadResult.Success(1), service.upload("viewer", listOf(event)))+ assertEquals(listOf("old-access", "new-access"), api.uploads.map { it.first })+ assertEquals(1, api.refreshes)+ assertEquals("new-refresh", store.read().tokens?.refreshToken)+ }++ @Test fun second_unauthorized_upload_clears_session_without_retry_loop() = runBlocking {+ val api = Api().apply { unauthorized = true }+ val store = Store(TraktStoredSession(tokens()))+ val service = service(store, api)+ service.load()++ assertEquals(TraktHistoryUploadResult.Disconnected, service.upload("viewer", listOf(event)))+ assertEquals(2, api.uploads.size)+ assertEquals(1, api.refreshes)+ assertNull(store.read().tokens)+ assertEquals(TraktMessage.RECONNECT_REQUIRED, service.state.value.message)+ }++ @Test fun rate_limit_and_ambiguous_transport_failure_are_not_retried() = runBlocking {+ for (failure in listOf(TraktApiException(429), java.io.IOException("timeout"))) {+ val api = Api().apply { this.failure = failure }+ val store = Store(TraktStoredSession(tokens()))+ val service = service(store, api)+ service.load()++ assertEquals(TraktHistoryUploadResult.Failed, service.upload("viewer", listOf(event)))+ assertEquals(1, api.uploads.size)+ assertEquals(0, api.refreshes)+ assertNotNull(store.read().tokens)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadSyncTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadSyncTest.ktnew file mode 100644index 00000000..4baace4e--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktHistoryUploadSyncTest.kt@@ -0,0 +1,147 @@+package com.streamvault.data.trakt++import com.streamvault.data.local.dao.*+import com.streamvault.data.mapper.toEntity+import com.streamvault.domain.model.*+import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.*+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.flowOf+import kotlinx.coroutines.runBlocking+import org.junit.Assert.*+import org.junit.Test+import org.mockito.kotlin.*++class TraktHistoryUploadSyncTest {+ private val account = mock<TraktAccount>()+ private val state = MutableStateFlow(TraktAccountState(configured = true, connected = true, username = "viewer"))+ private val source = mock<TraktHistorySource>()+ private val movies = mock<MovieDao>()+ private val series = mock<SeriesDao>()+ private val episodes = mock<EpisodeDao>()+ private val history = mock<PlaybackHistoryRepository>()+ private val emptyPage = TraktHistoryResult.Success(TraktHistoryPage(emptyList(), 1, false))++ init {+ whenever(account.state).thenReturn(state)+ runBlocking { whenever(source.history(1)).thenReturn(emptyPage) }+ whenever(history.getRecentlyWatched(5001)).thenReturn(flowOf(emptyList()))+ runBlocking { whenever(history.isIncognitoModeEnabled()).thenReturn(false) }+ }++ private fun service() = TraktHistorySyncService(account, source, movies, series, episodes, history)+ private fun completedMovie(contentId: Long, tmdbId: Long, watchedAt: Long, providerId: Long = 5) =+ PlaybackHistory(contentId = contentId, contentType = ContentType.MOVIE, providerId = providerId,+ title = "Movie $contentId", streamUrl = "https://provider.test/$contentId", lastWatchedAt = watchedAt,+ watchedStatus = PlaybackWatchedStatus.COMPLETED_AUTO)++ @Test fun uploads_only_exact_completed_local_movies_with_captured_owner() = runBlocking {+ val watchedAt = 1_700_000_000_123L+ val row = completedMovie(contentId = 77, tmdbId = 603, watchedAt = watchedAt)+ whenever(history.getRecentlyWatched(5001)).thenReturn(flowOf(listOf(row)))+ whenever(movies.getByIdsSync(listOf(77))).thenReturn(listOf(+ Movie(id = 77, name = "Movie 77", providerId = 5, tmdbId = 603).toEntity()))+ whenever(source.upload(eq("viewer"), any())).thenReturn(TraktHistoryUploadResult.Success(1))++ val result = service().sync()++ assertEquals(TraktHistorySyncResult.Success(0, 0, 0, 0, uploaded = 1, moreUploads = false), result)+ val events = argumentCaptor<List<TraktHistoryUpload>>()+ verify(source).upload(eq("viewer"), events.capture())+ assertEquals(listOf(TraktHistoryUpload(TraktMediaIdentity.MovieId(603), watchedAt)), events.firstValue)+ }++ @Test fun remote_history_in_the_same_minute_suppresses_duplicate_upload() = runBlocking {+ val watchedAt = 1_700_000_000_123L+ val minute = watchedAt / 60_000 * 60_000+ whenever(source.history(1)).thenReturn(TraktHistoryResult.Success(TraktHistoryPage(+ listOf(TraktHistoryEntry(1, TraktMediaIdentity.MovieId(603), minute)), 1, false)))+ whenever(movies.getByTmdbIdsSync(listOf(603))).thenReturn(emptyList())+ whenever(history.getRecentlyWatched(5001)).thenReturn(flowOf(listOf(completedMovie(77, 603, watchedAt))))+ whenever(movies.getByIdsSync(listOf(77))).thenReturn(listOf(+ Movie(id = 77, name = "Movie 77", providerId = 5, tmdbId = 603).toEntity()))++ val result = service().sync()++ assertTrue(result is TraktHistorySyncResult.Success)+ verify(source, never()).upload(any(), any())+ Unit+ }++ @Test fun upload_batch_is_capped_at_one_hundred_and_reports_remaining_work() = runBlocking {+ val rows = (1L..101L).map { id -> completedMovie(id, 1_000 + id, 1_700_000_000_000L + id) }+ whenever(history.getRecentlyWatched(5001)).thenReturn(flowOf(rows))+ whenever(movies.getByIdsSync((1L..101L).toList())).thenReturn(rows.map { row ->+ Movie(id = row.contentId, name = row.title, providerId = row.providerId,+ tmdbId = 1_000 + row.contentId).toEntity()+ })+ whenever(source.upload(eq("viewer"), any())).thenReturn(TraktHistoryUploadResult.Success(100))++ val result = service().sync()++ assertEquals(TraktHistorySyncResult.Success(0, 0, 0, 0, uploaded = 100, moreUploads = true), result)+ val events = argumentCaptor<List<TraktHistoryUpload>>()+ verify(source).upload(eq("viewer"), events.capture())+ assertEquals(100, events.firstValue.size)+ assertEquals(TraktMediaIdentity.MovieId(1001), events.firstValue.first().media)+ }++ @Test fun incognito_stops_before_remote_history_or_catalog_access() = runBlocking {+ whenever(history.isIncognitoModeEnabled()).thenReturn(true)++ assertEquals(TraktHistorySyncResult.Failure(TraktSyncFailure.INCOGNITO), service().sync())+ verifyNoInteractions(source, movies, series, episodes)+ }++ @Test fun incognito_enabled_while_resolving_candidates_blocks_outbound_write() = runBlocking {+ var incognitoEnabled = false+ whenever(history.isIncognitoModeEnabled()).thenAnswer { incognitoEnabled }+ val row = completedMovie(77, 603, 1_700_000_000_123L)+ whenever(history.getRecentlyWatched(5001)).thenAnswer {+ incognitoEnabled = true+ flowOf(listOf(row))+ }+ whenever(movies.getByIdsSync(listOf(77))).thenReturn(listOf(+ Movie(id = 77, name = "Movie 77", providerId = 5, tmdbId = 603).toEntity()))++ assertEquals(TraktHistorySyncResult.Failure(TraktSyncFailure.INCOGNITO), service().sync())+ verify(source, never()).upload(any(), any())+ Unit+ }++ @Test fun account_switch_during_local_resolution_aborts_before_upload() = runBlocking {+ val row = completedMovie(77, 603, 1_700_000_000_123L)+ whenever(history.getRecentlyWatched(5001)).thenReturn(flowOf(listOf(row)))+ whenever(movies.getByIdsSync(listOf(77))).thenAnswer {+ state.value = state.value.copy(username = "another-viewer")+ listOf(Movie(id = 77, name = "Movie 77", providerId = 5, tmdbId = 603).toEntity())+ }++ assertEquals(TraktHistorySyncResult.Failure(TraktSyncFailure.ACCOUNT_CHANGED), service().sync())+ verify(source, never()).upload(any(), any())+ Unit+ }++ @Test fun uploads_episode_only_when_catalog_series_and_episode_provider_match() = runBlocking {+ val watchedAt = 1_700_000_000_123L+ val row = PlaybackHistory(contentId = 10, contentType = ContentType.SERIES_EPISODE, providerId = 5,+ title = "Show - Episode", streamUrl = "https://provider.test/episode", lastWatchedAt = watchedAt,+ watchedStatus = PlaybackWatchedStatus.COMPLETED_MANUAL, seriesId = 42, seasonNumber = 2, episodeNumber = 3)+ whenever(history.getRecentlyWatched(5001)).thenReturn(flowOf(listOf(row)))+ whenever(series.getByIdsSync(listOf(42))).thenReturn(listOf(+ Series(id = 42, name = "Show", providerId = 5, tmdbId = 1396).toEntity()))+ whenever(episodes.getEntitiesBySeriesSync(42)).thenReturn(listOf(+ Episode(id = 10, title = "Episode", seasonNumber = 2, episodeNumber = 3,+ seriesId = 42, providerId = 5).toEntity(),+ Episode(id = 11, title = "Wrong provider", seasonNumber = 2, episodeNumber = 3,+ seriesId = 42, providerId = 8).toEntity()))+ whenever(source.upload(eq("viewer"), any())).thenReturn(TraktHistoryUploadResult.Success(1))++ val result = service().sync()++ assertEquals(TraktHistorySyncResult.Success(0, 0, 0, 0, uploaded = 1, moreUploads = false), result)+ val events = argumentCaptor<List<TraktHistoryUpload>>()+ verify(source).upload(eq("viewer"), events.capture())+ assertEquals(listOf(TraktHistoryUpload(TraktMediaIdentity.EpisodeId(1396, 2, 3), watchedAt)), events.firstValue)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktProfileApiTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktProfileApiTest.ktnew file mode 100644index 00000000..96a65cfd--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktProfileApiTest.kt@@ -0,0 +1,39 @@+package com.streamvault.data.trakt++import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.assertEquals+import org.junit.Assert.assertTrue+import org.junit.Test++class TraktProfileApiTest {+ @Test fun `user settings profile parses rich textual account details`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""{+ "user": {+ "username":"viewer", "name":"Stream Vault User", "location":"Jerusalem",+ "about":"Media fan", "gender":"male", "age":36,+ "joined_at":"2020-02-03T10:11:12.000Z", "vip":true,+ "images":{"avatar":{"full":"walter-r2.trakt.tv/avatar.webp"}}+ }+ }"""))+ val api = TraktApiClient(+ TraktConfig("client", "https://example.org/callback"), OkHttpClient(), server.url("/"),+ )++ val profile = api.profile("token")++ assertEquals("viewer", profile.username)+ assertEquals("Stream Vault User", profile.name)+ assertEquals("Jerusalem", profile.location)+ assertEquals("Media fan", profile.about)+ assertEquals("male", profile.gender)+ assertEquals(36, profile.age)+ assertEquals("2020-02-03T10:11:12.000Z", profile.joinedAt)+ assertTrue(profile.vip)+ assertEquals("/users/settings", server.takeRequest().path)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktRatingsServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktRatingsServiceTest.ktnew file mode 100644index 00000000..830de165--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktRatingsServiceTest.kt@@ -0,0 +1,143 @@+package com.streamvault.data.trakt++import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktRatingActionResult+import com.streamvault.domain.trakt.TraktRatingFailure+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingPage+import com.streamvault.domain.trakt.TraktRatingPageResult+import com.streamvault.domain.trakt.TraktRatingRefreshResult+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktRatingWriteResult+import com.streamvault.domain.trakt.TraktRatingsSource+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Assert.assertTrue+import org.junit.Test+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever++class TraktRatingsServiceTest {+ private class Account(connected: Boolean = true) : TraktAccount {+ val mutableState = MutableStateFlow(+ TraktAccountState(configured = true, connected = connected, username = if (connected) "viewer" else null),+ )+ override val state = mutableState+ override suspend fun load() = Unit+ override suspend fun beginSignIn() = error("Not used")+ override suspend fun completeSignIn(callback: String) = error("Not used")+ override suspend fun cancelSignIn() = Unit+ override suspend fun disconnect() { mutableState.value = mutableState.value.copy(connected = false, username = null) }+ override suspend fun refreshProfile() = Unit+ }++ private class Source : TraktRatingsSource {+ val writes = mutableListOf<Pair<TraktRatingIdentity, Int>>()+ var result: TraktRatingWriteResult = TraktRatingWriteResult.Success+ var afterWrite: (() -> Unit)? = null+ val reads = mutableListOf<Pair<TraktRatingType, Int>>()+ var pages: MutableMap<Int, TraktRatingPage> = mutableMapOf()+ var failedReadPage: Int? = null++ override suspend fun ratings(type: TraktRatingType, page: Int): TraktRatingPageResult {+ reads += type to page+ if (failedReadPage == page) return TraktRatingPageResult.Failed+ return TraktRatingPageResult.Success(pages[page] ?: TraktRatingPage(emptyList(), page, false))+ }++ override suspend fun setRating(identity: TraktRatingIdentity, rating: Int): TraktRatingWriteResult {+ writes += identity to rating+ afterWrite?.invoke()+ return result+ }+ }++ private fun service(account: Account, source: Source, incognito: Boolean = false): TraktRatingsService {+ val history: PlaybackHistoryRepository = mock()+ runBlocking { whenever(history.isIncognitoModeEnabled()).thenReturn(incognito) }+ return TraktRatingsService(account, source, history)+ }++ @Test fun `writes exact movie and show ratings`() = runBlocking {+ val source = Source()+ val service = service(Account(), source)+ val movie = TraktRatingIdentity(TraktRatingType.MOVIE, 603)+ val show = TraktRatingIdentity(TraktRatingType.SHOW, 1396)++ assertEquals(TraktRatingActionResult.Success, service.setRating(movie, 8))+ assertEquals(TraktRatingActionResult.Success, service.setRating(show, 10))+ assertEquals(listOf(movie to 8, show to 10), source.writes)+ }++ @Test fun `refresh stages all pages before replacing type cache and honors cache`() = runBlocking {+ val first = TraktRatingIdentity(TraktRatingType.MOVIE, 603)+ val second = TraktRatingIdentity(TraktRatingType.MOVIE, 550)+ val show = TraktRatingIdentity(TraktRatingType.SHOW, 1396)+ val source = Source().apply {+ pages[1] = TraktRatingPage(listOf(first to 8), 1, hasMore = true)+ pages[2] = TraktRatingPage(listOf(second to 9), 2, hasMore = false)+ }+ val service = service(Account(), source)++ assertEquals(TraktRatingRefreshResult.Success(2), service.refresh(TraktRatingType.MOVIE))+ assertEquals(8, service.state.value.rating(first))+ assertEquals(9, service.state.value.rating(second))+ assertEquals(TraktRatingRefreshResult.Success(2), service.refresh(TraktRatingType.MOVIE))+ assertEquals(listOf(TraktRatingType.MOVIE to 1, TraktRatingType.MOVIE to 2), source.reads)++ assertEquals(TraktRatingActionResult.Success, service.setRating(show, 10))+ assertEquals(10, service.state.value.rating(show))+ }++ @Test fun `failed later page keeps prior complete snapshot`() = runBlocking {+ val old = TraktRatingIdentity(TraktRatingType.MOVIE, 603)+ val source = Source().apply { pages[1] = TraktRatingPage(listOf(old to 7), 1, false) }+ val service = service(Account(), source)+ service.refresh(TraktRatingType.MOVIE)++ source.pages[1] = TraktRatingPage(+ listOf(TraktRatingIdentity(TraktRatingType.MOVIE, 550) to 8), 1, true,+ )+ source.failedReadPage = 2+ assertEquals(+ TraktRatingRefreshResult.Failure(TraktRatingFailure.REQUEST_FAILED),+ service.refresh(TraktRatingType.MOVIE, force = true),+ )+ assertEquals(7, service.state.value.rating(old))+ }++ @Test fun `disconnected account and incognito do not write`() = runBlocking {+ val source = Source()+ val identity = TraktRatingIdentity(TraktRatingType.MOVIE, 603)+ assertEquals(+ TraktRatingActionResult.Failure(TraktRatingFailure.DISCONNECTED),+ service(Account(connected = false), source).setRating(identity, 7),+ )+ assertEquals(+ TraktRatingActionResult.Failure(TraktRatingFailure.INCOGNITO),+ service(Account(), source, incognito = true).setRating(identity, 7),+ )+ assertTrue(source.writes.isEmpty())+ }++ @Test fun `failed write and account change are reported`() = runBlocking {+ val identity = TraktRatingIdentity(TraktRatingType.SHOW, 1396)+ val failedSource = Source().apply { result = TraktRatingWriteResult.Failed }+ assertEquals(+ TraktRatingActionResult.Failure(TraktRatingFailure.REQUEST_FAILED),+ service(Account(), failedSource).setRating(identity, 4),+ )++ val account = Account()+ val changingSource = Source().apply {+ afterWrite = { account.mutableState.value = account.mutableState.value.copy(username = "other") }+ }+ assertEquals(+ TraktRatingActionResult.Failure(TraktRatingFailure.ACCOUNT_CHANGED),+ service(account, changingSource).setRating(identity, 4),+ )+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktScrobbleApiTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktScrobbleApiTest.ktnew file mode 100644index 00000000..f7e6b266--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktScrobbleApiTest.kt@@ -0,0 +1,74 @@+package com.streamvault.data.trakt++import com.google.gson.Gson+import com.google.gson.JsonObject+import com.streamvault.domain.trakt.*+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.*+import org.junit.Test++class TraktScrobbleApiTest {+ private fun api(server: MockWebServer) = TraktApiClient(+ TraktConfig("client", "https://example.org/callback"), OkHttpClient(), server.url("/"))++ @Test fun `movie uses attached ID fractional progress and required auth headers`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setResponseCode(201).setBody("{}"))+ assertTrue(api(server).scrobble("test-access", TraktScrobbleEvent(+ TraktMediaIdentity.MovieId(603), TraktScrobbleAction.START, 12.5)))+ val request = server.takeRequest()+ assertEquals("/scrobble/start", request.path)+ assertEquals("POST", request.method)+ assertEquals("Bearer test-access", request.getHeader("Authorization"))+ assertEquals("client", request.getHeader("trakt-api-key"))+ assertEquals("2", request.getHeader("trakt-api-version"))+ val body = Gson().fromJson(request.body.readUtf8(), JsonObject::class.java)+ assertEquals(603, body.getAsJsonObject("movie").getAsJsonObject("ids")["tmdb"].asInt)+ assertEquals(12.5, body["progress"].asDouble, .001)+ assertFalse(body.has("episode"))+ }+ }++ @Test fun `episode resolves exact show and numbers once then reuses episode ID`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[{"type":"show","show":{"ids":{"tmdb":1396,"trakt":1}}}]"""))+ server.enqueue(MockResponse().setBody("""{"season":2,"number":3,"ids":{"trakt":123}}"""))+ repeat(2) { server.enqueue(MockResponse().setResponseCode(201).setBody("{}")) }+ val api = api(server)+ val event = TraktScrobbleEvent(TraktMediaIdentity.EpisodeId(1396, 2, 3), TraktScrobbleAction.START, 5.0)+ assertTrue(api.scrobble("test-access", event))+ assertTrue(api.scrobble("test-access", event.copy(action = TraktScrobbleAction.PAUSE)))+ assertEquals("/search/tmdb/1396?type=show", server.takeRequest().path)+ assertEquals("/shows/1/seasons/2/episodes/3", server.takeRequest().path)+ val post = server.takeRequest()+ val body = Gson().fromJson(post.body.readUtf8(), JsonObject::class.java)+ assertEquals(123, body.getAsJsonObject("episode").getAsJsonObject("ids")["trakt"].asInt)+ assertFalse(body.has("show"))+ assertEquals("/scrobble/pause", server.takeRequest().path)+ assertEquals(4, server.requestCount)+ }+ }++ @Test fun `ambiguous show ID never submits a write`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[{"type":"show","show":{"ids":{"tmdb":1396,"trakt":1}}},{"type":"show","show":{"ids":{"tmdb":1396,"trakt":2}}}]"""))+ assertFalse(api(server).scrobble("test-access", TraktScrobbleEvent(+ TraktMediaIdentity.EpisodeId(1396, 2, 3), TraktScrobbleAction.STOP, 95.0)))+ assertEquals(1, server.requestCount)+ assertEquals("GET", server.takeRequest().method)+ }+ }++ @Test fun `episode numbers returned by lookup must match before writing`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[{"type":"show","show":{"ids":{"tmdb":1396,"trakt":1}}}]"""))+ server.enqueue(MockResponse().setBody("""{"season":2,"number":4,"ids":{"trakt":123}}"""))+ assertFalse(api(server).scrobble("test-access", TraktScrobbleEvent(+ TraktMediaIdentity.EpisodeId(1396, 2, 3), TraktScrobbleAction.START, 5.0)))+ assertEquals(2, server.requestCount)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktScrobbleAuthTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktScrobbleAuthTest.ktnew file mode 100644index 00000000..9eb7d491--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktScrobbleAuthTest.kt@@ -0,0 +1,89 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.*+import kotlinx.coroutines.async+import kotlinx.coroutines.awaitAll+import kotlinx.coroutines.coroutineScope+import kotlinx.coroutines.delay+import kotlinx.coroutines.runBlocking+import org.junit.Assert.*+import org.junit.Test++class TraktScrobbleAuthTest {+ private class Store(var session: TraktStoredSession) : TraktTokenStore {+ override fun read() = session+ override fun write(session: TraktStoredSession) { this.session = session }+ }+ private class Api : TraktApi, TraktPlaybackApi {+ var refreshes = 0+ val writes = mutableListOf<String>()+ var failure: TraktApiException? = null+ var rejectOld = false+ override suspend fun exchange(code: String, verifier: String) = error("Not used")+ override suspend fun refresh(refreshToken: String): TraktTokens {+ refreshes+++ delay(10)+ return TraktTokens("new-access", "new-refresh", 1000, 1000)+ }+ override suspend fun username(accessToken: String) = "viewer"+ override suspend fun scrobble(accessToken: String, event: TraktScrobbleEvent): Boolean {+ writes += accessToken+ failure?.let { throw it }+ if (rejectOld && accessToken == "old-access") throw TraktApiException(401)+ return true+ }+ }+ private val event = TraktScrobbleEvent(TraktMediaIdentity.MovieId(603), TraktScrobbleAction.START, 20.0)+ private fun service(store: Store, api: Api) = TraktAuthService(+ TraktConfig("client", "https://example.org/callback"), store, api, now = { 1000 })+ private fun tokens(expired: Boolean = false) = TraktTokens("old-access", "old-refresh", if (expired) 1 else 1000, 1000)++ @Test fun `concurrent playback writes rotate expired pair once and persist replacement`() = runBlocking {+ val store = Store(TraktStoredSession(tokens(true)))+ val api = Api()+ val service = service(store, api)+ val outcomes = coroutineScope { List(3) { async { service.send(event) } }.awaitAll() }+ assertTrue(outcomes.all { it == TraktScrobbleOutcome.SENT })+ assertEquals(1, api.refreshes)+ assertEquals(listOf("new-access", "new-access", "new-access"), api.writes)+ assertTrue(store.read().tokens?.refreshToken == "new-refresh")+ }++ @Test fun `explicit unauthorized response refreshes once then resubmits with replacement`() = runBlocking {+ val store = Store(TraktStoredSession(tokens()))+ val api = Api().apply { rejectOld = true }+ assertEquals(TraktScrobbleOutcome.SENT, service(store, api).send(event))+ assertEquals(1, api.refreshes)+ assertEquals(listOf("old-access", "new-access"), api.writes)+ }++ @Test fun `second unauthorized response clears session without retry loop`() = runBlocking {+ val store = Store(TraktStoredSession(tokens()))+ val api = Api().apply { failure = TraktApiException(401) }+ val service = service(store, api)+ assertEquals(TraktScrobbleOutcome.FAILED, service.send(event))+ assertEquals(2, api.writes.size)+ assertEquals(1, api.refreshes)+ assertNull(store.read().tokens)+ assertEquals(TraktMessage.RECONNECT_REQUIRED, service.state.value.message)+ }++ @Test fun `disconnected and rate limited writes do not retry or refresh`() = runBlocking {+ val api = Api()+ assertEquals(TraktScrobbleOutcome.DISCONNECTED,+ service(Store(TraktStoredSession()), api).send(event))+ assertTrue(api.writes.isEmpty())+ api.failure = TraktApiException(429)+ assertEquals(TraktScrobbleOutcome.FAILED,+ service(Store(TraktStoredSession(tokens())), api).send(event))+ assertEquals(1, api.writes.size)+ assertEquals(0, api.refreshes)+ }++ @Test fun `duplicate stop is terminal and does not repeat a history write`() = runBlocking {+ val api = Api().apply { failure = TraktApiException(409) }+ assertEquals(TraktScrobbleOutcome.DUPLICATE,+ service(Store(TraktStoredSession(tokens())), api).send(event.copy(action = TraktScrobbleAction.STOP)))+ assertEquals(1, api.writes.size)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistApiTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistApiTest.ktnew file mode 100644index 00000000..bbb4758c--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistApiTest.kt@@ -0,0 +1,86 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistType+import kotlinx.coroutines.runBlocking+import okhttp3.OkHttpClient+import okhttp3.mockwebserver.MockResponse+import okhttp3.mockwebserver.MockWebServer+import org.junit.Assert.assertEquals+import org.junit.Assert.assertFalse+import org.junit.Assert.assertTrue+import org.junit.Test++class TraktWatchlistApiTest {+ private fun api(server: MockWebServer) = TraktApiClient(+ TraktConfig("client", "https://example.org/callback"), OkHttpClient(), server.url("/"))++ @Test fun `watchlist pages parse exact movie and show TMDB ids`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setHeader("X-Pagination-Page-Count", "2").setBody("""[+ {"rank":1,"movie":{"title":"Movie","ids":{"tmdb":603}}},+ {"rank":2,"movie":{"title":"Missing id","ids":{"trakt":2}}}+ ]"""))+ server.enqueue(MockResponse().setBody("""[+ {"rank":1,"show":{"title":"Show","ids":{"tmdb":1396}}}+ ]"""))+ val api = api(server)++ val movies = api.watchlist("token", TraktWatchlistType.MOVIE, 1)+ val shows = api.watchlist("token", TraktWatchlistType.SHOW, 1)++ assertEquals(listOf(TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603)), movies.items)+ assertEquals(1, movies.skippedItems)+ assertTrue(movies.hasMore)+ assertEquals(listOf(TraktWatchlistIdentity(TraktWatchlistType.SHOW, 1396)), shows.items)+ assertFalse(shows.hasMore)+ assertEquals("/sync/watchlist/movies?page=1&limit=100", server.takeRequest().path)+ val showRequest = server.takeRequest()+ assertEquals("/sync/watchlist/shows?page=1&limit=100", showRequest.path)+ assertEquals("Bearer token", showRequest.getHeader("Authorization"))+ assertEquals("client", showRequest.getHeader("trakt-api-key"))+ }+ }++ @Test fun `watchlist writes use only exact TMDB ids and add or remove endpoint`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("{}"))+ server.enqueue(MockResponse().setBody("{}"))+ val api = api(server)++ api.setWatchlisted("token", TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603), true)+ api.setWatchlisted("token", TraktWatchlistIdentity(TraktWatchlistType.SHOW, 1396), false)++ val add = server.takeRequest()+ assertEquals("POST", add.method)+ assertEquals("/sync/watchlist", add.path)+ assertEquals("""{"movies":[{"ids":{"tmdb":603}}]}""", add.body.readUtf8())+ assertEquals("Bearer token", add.getHeader("Authorization"))+ val remove = server.takeRequest()+ assertEquals("POST", remove.method)+ assertEquals("/sync/watchlist/remove", remove.path)+ assertEquals("""{"shows":[{"ids":{"tmdb":1396}}]}""", remove.body.readUtf8())+ }+ }++ @Test fun `bad watchlist identifiers are skipped and pagination falls back to raw row count`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody(List(100) { "{}" }.joinToString(",", "[", "]")))+ val page = api(server).watchlist("token", TraktWatchlistType.MOVIE, 1)+ assertTrue(page.hasMore)+ assertEquals(100, page.skippedItems)+ assertTrue(page.items.isEmpty())+ }+ }++ @Test fun `fractional TMDB IDs are skipped rather than truncated`() = runBlocking {+ MockWebServer().use { server ->+ server.enqueue(MockResponse().setBody("""[+ {"rank":1,"movie":{"title":"Fractional","ids":{"tmdb":603.5}}}+ ]"""))+ val page = api(server).watchlist("token", TraktWatchlistType.MOVIE, 1)+ assertTrue(page.items.isEmpty())+ assertEquals(1, page.skippedItems)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistAuthTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistAuthTest.ktnew file mode 100644index 00000000..dc331ac7--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistAuthTest.kt@@ -0,0 +1,91 @@+package com.streamvault.data.trakt++import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistPage+import com.streamvault.domain.trakt.TraktWatchlistPageResult+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktWatchlistWriteResult+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Assert.assertNull+import org.junit.Assert.assertTrue+import org.junit.Test++class TraktWatchlistAuthTest {+ private class Store(var session: TraktStoredSession) : TraktTokenStore {+ override fun read() = session+ override fun write(session: TraktStoredSession) { this.session = session }+ }++ private class Api : TraktApi, TraktWatchlistApi {+ var refreshes = 0+ val reads = mutableListOf<String>()+ val writes = mutableListOf<String>()+ var rejectOld = false+ var unauthorized = false+ var writeFailure: Exception? = null++ override suspend fun exchange(code: String, verifier: String) = error("Not used")+ override suspend fun refresh(refreshToken: String): TraktTokens {+ refreshes+++ return TraktTokens("new-access", "new-refresh", 1000, 1000)+ }+ override suspend fun username(accessToken: String) = "viewer"+ override suspend fun watchlist(accessToken: String, type: TraktWatchlistType, page: Int): TraktWatchlistPage {+ reads += accessToken+ if (unauthorized || (rejectOld && accessToken == "old-access")) throw TraktApiException(401)+ return TraktWatchlistPage(emptyList(), page, false)+ }+ override suspend fun setWatchlisted(+ accessToken: String,+ identity: TraktWatchlistIdentity,+ watchlisted: Boolean,+ ) {+ writes += accessToken+ writeFailure?.let { throw it }+ if (unauthorized || (rejectOld && accessToken == "old-access")) throw TraktApiException(401)+ }+ }++ private fun tokens() = TraktTokens("old-access", "old-refresh", 1000, 1000)+ private fun service(store: Store, api: Api) = TraktAuthService(+ TraktConfig("client", "https://example.org/callback"), store, api, now = { 1000 })+ private val identity = TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603)++ @Test fun `watchlist read retries exactly once after explicit unauthorized`() = runBlocking {+ val api = Api().apply { rejectOld = true }+ val store = Store(TraktStoredSession(tokens()))+ val source = service(store, api)++ assertTrue(source.watchlist(TraktWatchlistType.MOVIE, 1) is TraktWatchlistPageResult.Success)+ assertEquals(listOf("old-access", "new-access"), api.reads)+ assertEquals(1, api.refreshes)+ assertEquals("new-refresh", store.read().tokens?.refreshToken)+ }++ @Test fun `watchlist write retries a rejected token once but never retries ambiguous failure`() = runBlocking {+ val api = Api().apply { rejectOld = true }+ val store = Store(TraktStoredSession(tokens()))+ val source = service(store, api)+ assertEquals(TraktWatchlistWriteResult.Success, source.setWatchlisted(identity, true))+ assertEquals(listOf("old-access", "new-access"), api.writes)+ assertEquals(1, api.refreshes)++ api.writeFailure = java.io.IOException("timeout")+ assertEquals(TraktWatchlistWriteResult.Failed, source.setWatchlisted(identity, false))+ assertEquals(3, api.writes.size)+ assertEquals(1, api.refreshes)+ assertTrue(store.read().tokens != null)+ }++ @Test fun `second unauthorized watchlist read clears credentials and requires reconnect`() = runBlocking {+ val api = Api().apply { unauthorized = true }+ val store = Store(TraktStoredSession(tokens()))+ val source = service(store, api)++ assertEquals(TraktWatchlistPageResult.Disconnected, source.watchlist(TraktWatchlistType.SHOW, 1))+ assertEquals(2, api.reads.size)+ assertEquals(1, api.refreshes)+ assertNull(store.read().tokens)+ }+}diff --git a/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistServiceTest.kt b/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistServiceTest.ktnew file mode 100644index 00000000..7602521a--- /dev/null+++ b/data/src/test/java/com/streamvault/data/trakt/TraktWatchlistServiceTest.kt@@ -0,0 +1,155 @@+package com.streamvault.data.trakt++import com.streamvault.domain.repository.PlaybackHistoryRepository+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktMessage+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistPage+import com.streamvault.domain.trakt.TraktWatchlistPageResult+import com.streamvault.domain.trakt.TraktWatchlistRefreshResult+import com.streamvault.domain.trakt.TraktWatchlistSource+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktWatchlistWriteResult+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.runBlocking+import org.junit.Assert.assertEquals+import org.junit.Assert.assertFalse+import org.junit.Assert.assertTrue+import org.junit.Test+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever++class TraktWatchlistServiceTest {+ private class Account : TraktAccount {+ val mutableState = MutableStateFlow(TraktAccountState(configured = true, connected = true, username = "viewer"))+ override val state = mutableState+ override suspend fun load() = Unit+ override suspend fun beginSignIn() = error("Not used")+ override suspend fun completeSignIn(callback: String) = error("Not used")+ override suspend fun cancelSignIn() = Unit+ override suspend fun disconnect() { mutableState.value = mutableState.value.copy(connected = false, username = null) }+ override suspend fun refreshProfile() = Unit+ }++ private class Source : TraktWatchlistSource {+ val pages = mutableMapOf<Pair<TraktWatchlistType, Int>, TraktWatchlistPageResult>()+ val reads = mutableListOf<Pair<TraktWatchlistType, Int>>()+ val writes = mutableListOf<Pair<TraktWatchlistIdentity, Boolean>>()+ var writeResult: TraktWatchlistWriteResult = TraktWatchlistWriteResult.Success+ var onRead: (() -> Unit)? = null++ override suspend fun watchlist(type: TraktWatchlistType, page: Int): TraktWatchlistPageResult {+ reads += type to page+ onRead?.invoke()+ return pages[type to page] ?: TraktWatchlistPageResult.Success(TraktWatchlistPage(emptyList(), page, false))+ }++ override suspend fun setWatchlisted(identity: TraktWatchlistIdentity, watchlisted: Boolean): TraktWatchlistWriteResult {+ writes += identity to watchlisted+ return writeResult+ }+ }++ private fun service(account: Account, source: Source, incognito: Boolean = false): TraktWatchlistService {+ val history: PlaybackHistoryRepository = mock()+ runBlocking { whenever(history.isIncognitoModeEnabled()).thenReturn(incognito) }+ return TraktWatchlistService(account, source, history)+ }++ @Test fun `refresh stages movie and show pages and cached refresh avoids repeated reads`() = runBlocking {+ val account = Account()+ val source = Source()+ val movie = TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603)+ val show = TraktWatchlistIdentity(TraktWatchlistType.SHOW, 1396)+ source.pages[TraktWatchlistType.MOVIE to 1] = TraktWatchlistPageResult.Success(+ TraktWatchlistPage(listOf(movie), page = 1, hasMore = true))+ source.pages[TraktWatchlistType.MOVIE to 2] = TraktWatchlistPageResult.Success(+ TraktWatchlistPage(emptyList(), page = 2, hasMore = false))+ source.pages[TraktWatchlistType.SHOW to 1] = TraktWatchlistPageResult.Success(+ TraktWatchlistPage(listOf(show), page = 1, hasMore = false, skippedItems = 2))+ val service = service(account, source)++ assertEquals(TraktWatchlistRefreshResult.Success(2, skipped = 2), service.refresh())+ assertEquals(setOf(movie, show), service.state.value.items)+ assertTrue(service.state.value.loaded)+ val readsAfterInitial = source.reads.toList()+ assertEquals(TraktWatchlistRefreshResult.Success(2), service.refresh())+ assertEquals(readsAfterInitial, source.reads)++ assertEquals(TraktWatchlistRefreshResult.Success(2, skipped = 2), service.refresh(force = true))+ assertEquals(6, source.reads.size)+ }++ @Test fun `set action changes only the exact item after successful remote write`() = runBlocking {+ val account = Account()+ val source = Source()+ val service = service(account, source)+ val movie = TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603)+ val show = TraktWatchlistIdentity(TraktWatchlistType.SHOW, 1396)+ assertTrue(service.refresh() is TraktWatchlistRefreshResult.Success)++ assertEquals(com.streamvault.domain.trakt.TraktWatchlistActionResult.Success,+ service.setWatchlisted(movie, true))+ assertEquals(setOf(movie), service.state.value.items)+ assertEquals(com.streamvault.domain.trakt.TraktWatchlistActionResult.Success,+ service.setWatchlisted(show, false))+ assertEquals(listOf(movie to true), source.writes)+ assertEquals(com.streamvault.domain.trakt.TraktWatchlistActionResult.Success,+ service.setWatchlisted(movie, false))+ assertTrue(service.state.value.items.isEmpty())+ assertEquals(listOf(movie to true, movie to false), source.writes)+ }++ @Test fun `incognito prevents watchlist reads and writes`() = runBlocking {+ val source = Source()+ val service = service(Account(), source, incognito = true)+ assertEquals(TraktWatchlistRefreshResult.Failure(com.streamvault.domain.trakt.TraktWatchlistFailure.INCOGNITO),+ service.refresh())+ assertEquals(com.streamvault.domain.trakt.TraktWatchlistActionResult.Failure(+ com.streamvault.domain.trakt.TraktWatchlistFailure.INCOGNITO), service.setWatchlisted(+ TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603), true))+ assertTrue(source.reads.isEmpty())+ assertTrue(source.writes.isEmpty())+ }++ @Test fun `account change during pagination discards staged items`() = runBlocking {+ val account = Account()+ val source = Source()+ source.pages[TraktWatchlistType.MOVIE to 1] = TraktWatchlistPageResult.Success(TraktWatchlistPage(+ listOf(TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603)), 1, hasMore = true))+ source.onRead = { account.mutableState.value = account.mutableState.value.copy(username = "other") }+ val service = service(account, source)++ assertEquals(TraktWatchlistRefreshResult.Failure(com.streamvault.domain.trakt.TraktWatchlistFailure.ACCOUNT_CHANGED),+ service.refresh())+ assertTrue(service.state.value.items.isEmpty())+ assertFalse(service.state.value.loaded)+ }++ @Test fun `failed pagination leaves the staged list unavailable`() = runBlocking {+ val source = Source()+ source.pages[TraktWatchlistType.MOVIE to 1] = TraktWatchlistPageResult.Success(TraktWatchlistPage(+ listOf(TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603)), 1, hasMore = true))+ source.pages[TraktWatchlistType.MOVIE to 2] = TraktWatchlistPageResult.Failed+ val service = service(Account(), source)++ assertEquals(TraktWatchlistRefreshResult.Failure(com.streamvault.domain.trakt.TraktWatchlistFailure.REQUEST_FAILED),+ service.refresh())+ assertTrue(service.state.value.items.isEmpty())+ assertFalse(service.state.value.loaded)+ }++ @Test fun `failed write clears busy state and does not claim the remote change`() = runBlocking {+ val source = Source().apply { writeResult = TraktWatchlistWriteResult.Failed }+ val service = service(Account(), source)+ val movie = TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 603)+ assertTrue(service.refresh() is TraktWatchlistRefreshResult.Success)++ assertEquals(com.streamvault.domain.trakt.TraktWatchlistActionResult.Failure(+ com.streamvault.domain.trakt.TraktWatchlistFailure.REQUEST_FAILED), service.setWatchlisted(movie, true))+ assertTrue(service.state.value.items.isEmpty())+ assertFalse(service.state.value.loaded)+ assertTrue(service.state.value.updating.isEmpty())+ }+}diff --git a/docs/StreamVault_Trakt_Integration_Plan.md b/docs/StreamVault_Trakt_Integration_Plan.mdnew file mode 100644index 00000000..5c403cf8--- /dev/null+++ b/docs/StreamVault_Trakt_Integration_Plan.md@@ -0,0 +1,1578 @@+# StreamVault — Trakt Integration Plan++> **Status:** Implementation plan based on the current Trakt developer documentation as of **October 11, 2026**.+> **Target:** StreamVault Android / self-hosted open-source media player.+> **Primary use case:** Let users connect their own Trakt account, automatically track playback, and optionally synchronize Trakt data such as history and watchlists.++## Implementation progress — October 12, 2026++Phase 1 account code is implemented in the Trakt integration worktree: PKCE/state,+dedicated HTTPS callback activity, encrypted atomic persistence, serialized rotating+refresh tokens, profile/status, connect/cancel/disconnect, API headers, and rate-limit+cooldown. Build and deployment instructions are in [TRAKT_SETUP.md](TRAKT_SETUP.md).++The supplied public Client ID and HTTPS callback URL are configured locally. The+existing StreamVault Trakt registration now uses the exact callback below. The+callback site is deployed and Android verifies its domain for the installed debug+APK. Real browser sign-in and callback delivery are **validated**. Firefox+157.0.1 from Mozilla's official archive is installed on the Codex_Trakt Android 16+AVD. The user completed login/consent, and StreamVault displayed+Connected with the account username. Profile refresh completed without an error.+After force-stopping the app (PID 2256) and relaunching (PID 3115), Connected and the+same username returned. No tokens or authorization codes were collected in evidence.++Phase 2's domain identity foundation has started: `TraktMediaIdentity` and its+resolver accept attached positive movie/show TMDB IDs, with exact episode numbers+and matching local series/provider ownership. Missing IDs, unknown episode numbers,+and inconsistent ownership return no identity; no title guessing is performed.+Season-zero specials are supported. Six domain tests and the debug build passed;+output is in `build/trakt-identity-validation.log`.++Phase 2 now includes exact episode resolution (show TMDB lookup followed by season/+episode lookup), a bounded successful-ID cache, start/pause/stop payloads, serialized+authenticated requests, and player wiring. The player reports identified VOD only;+live TV, catch-up, recordings, trailers, and unknown external media are excluded.+Duplicate ticks and buffering produce no extra requests. Session switches preserve+the old item's last observed progress, and stale starts/pauses are suppressed. A+bounded transition queue avoids accumulating position ticks while network calls run.+Completion and cleanup submit a final stop; transient engine recovery preserves the+session. Tracking failures do not crash playback or trigger ambiguous write retries.+An explicit 401 can refresh once and retry; duplicate-stop 409 responses are terminal.+Opening playback loads the saved account without requiring a visit to Trakt settings.++Domain, transport/authentication, and player-coordinator tests cover these behaviors.+Build, playback boundary verification, and app/data lint passed against existing+baselines. Output is in `build/trakt-scrobble-final-validation.log`; the final+exception-isolation follow-up is in `build/trakt-scrobble-safety-validation.log`.+The earlier targeted suites contained 11 domain, 25 data, and 6 player tests, all passing.+Real-account episode start/pause reporting was exercised on the signed-in+Codex_Trakt emulator for the exact-matched S.W.A.T. Exiles S1E1. Trakt returned+successful HTTP responses for start and pause, and the player showed “Tracking with+Trakt” then “Trakt tracking paused”; playback reached a decoded first frame. The+test paused at about 2:11 of 44:35 (about 5%), so it did not test watched-history+completion. Trakt's scrobble API saves a pause as playback progress; a stop above+80% is needed to create a watched-history entry. StreamVault does not yet read the+saved `/sync/playback` item back, so its badge confirms request acceptance, not the+persisted server-side progress row. No watchlist, favorites, personal-list, or+history-add request was part of this test. A non-focusable player badge now fades+in for three seconds when tracking status changes and stays available while player+controls are open. It also explains when the account needs connecting, content+cannot be tracked, no exact Trakt match exists, or a request fails. The duration-+late start case and status transitions have player unit coverage. Real movie+scrobbling, Cast/external-player tracking, and variant episode ownership mapping+remain unvalidated or unsupported.+Phase 3's read/match foundation is described below.+Phase 4 watchlist support is implemented; real-account UI acceptance remains open.+Phase 5 now includes movie/show Favorites write-through, movie/show user ratings,+personal custom-list management, and public discovery categories for trending+and popular movies/shows. Settings can independently hide each Movies/Series+Trending/Popular category. Settings also show the connected account's expanded text+profile and provide independent playback-scrobbling and history-sync controls.++Phase 5 custom lists (October 16): Settings loads the connected account's personal+lists and lets the user create private lists, inspect movie/show/season/episode+items, remove items, reorder entries, reorder lists, and delete a list after an+explicit confirmation. Movie, show, season, and episode detail actions can add or+remove the exact supported item in a selected list. The Trakt Lists dialog also+offers Create new list and creates a private list before returning to the picker.+List metadata and item pages use a five-minute account-scoped cache; item pages are+fetched only when a list is opened and are staged before replacing the cached list.+Incognito mode blocks reads and writes, account changes invalidate the operation,+explicit 401 responses refresh once, and uncertain list writes are not retried.+Episodes and seasons are matched through their parent show's TMDB identity and+resolved to exact Trakt IDs before writes. People entries and reordering remain+unsupported when Trakt does not return stable list-entry IDs. Focused catalog,+settings, and data unit tests pass; debug APK assembly and emulator UI acceptance+remain to be completed. Real-account list mutations remain unvalidated.++Phase 2 validation follow-up (October 12): the coordinator now sends pause/stop only+for an identity whose start succeeded. This prevents skipped intermediate sessions+or failed starts from creating watched history through a later high-progress stop.+A Robolectric integration test drives the production player coordinator, account+service, HTTP client, and encrypted disk store through movie start/pause/resume,+movie-to-episode switching, exact episode resolution, and completion. It uses a+synthetic account and MockWebServer, never real Trakt writes. It passed with the+debug build; output is in `build/trakt-playback-integration-validation.log`.+The failed/skipped-start regressions are covered by the player tests; follow-up+test/boundary/lint output is in `build/trakt-playback-regression-validation.log`.+At the time of this synthetic follow-up, the isolated emulator was closed and real+VOD scrobbling acceptance had not yet been run; the later signed-in episode check+is recorded above.++Phase 3 read/match foundation (October 12): `TraktHistorySource` fetches one+authenticated page of mixed movie/episode history at a time (100 records per+request), sharing the same token lock and rotating refresh handling as playback.+Pagination uses Trakt's response header, with raw row-count fallback. Invalid dates,+missing IDs, fractional identifiers, and unknown types are skipped with a count;+IDs retain 64-bit precision. `TraktHistoryIndex` deduplicates repeated history IDs+and refuses conflicting media identities. Its merge policy produces explicit import+candidates, preserving newer local rewatch progress, manual completion, and larger+local play counts. A completion import advances older progress to its known duration+so existing catalog queries reflect the watched state. Remote absence never removes+local history.++Phase 3 now has a manual Settings → Trakt → Sync Now action. It stages up to 50+pages before writing; a failed read or exceeded limit imports nothing. Cached movie/+series rows are matched in bounded TMDB batches, and episodes require exact numbers+and provider/series ownership. Import candidates are rechecked under the playback+repository lock and inside a Room transaction before history and catalog projections+are updated together. Repeated imports do not increment plays or rewrite the watch+time. Incognito mode prevents imports, and account changes abort the run. The UI+reports imported, uploaded, unchanged, unmatched, and skipped counts, or partial+counts after a failure. Sync Now also uploads up to 100 newest completed local events+per run, resolved only by exact TMDB and episode ownership. It compares all staged+history first, uses stable UTC minute timestamps, and stops on a failed write; the+next manual run reconciles again before posting. Incognito mode blocks both sync+directions. The local catalog stores each item's latest watch time, so earlier+rewatches cannot be reconstructed as separate events. There is no automatic polling.+Real-account sync/device UI acceptance remains open. Test/build/lint output is in+`build/trakt-history-import-final-validation.log`, including Room persistence and+unwatched-count checks.+See [TRAKT_HISTORY_SYNC.md](TRAKT_HISTORY_SYNC.md).++Outbound synchronization now has focused MockWebServer and service-level coverage+for request payloads, exact episode lookup, UTC minute timestamps, accepted and+unmatched response counts, same-minute reconciliation, account ownership, one-time+401 refresh, ambiguous-write retry suppression, incognito blocking, and the 100-event+per-run cap. The full Trakt domain and data test packages pass (18 domain and 52 data+tests); all use local mocks, with no real-account history writes. Real-account+Sync Now also completed on the isolated Codex_Trakt emulator using the saved connected+account. The UI reported 0 imported, 0 uploaded, 0 unchanged, 0 unmatched, and 0+skipped. That emulator has no provider/catalog, so this confirms the authenticated+empty-history read and result UI without changing Trakt history; item matching,+non-empty import, and outbound upload still need acceptance against a real library.+Trakt's current API+normalizes `watched_at` to the minute and its API team says equal item/timestamp pairs+deduplicate, although the current contract still contains an older warning. StreamVault+preflights the complete staged history and canonicalizes timestamps before uploads.++Phase 4 watchlist implementation (October 12): authenticated movie/show list reads+and explicit add/remove actions share the account service's rotating-token lock.+Movie and show detail pages show Trakt bookmark actions only for positive TMDB IDs;+titles are never used as a fallback. Reads are staged before the account-scoped+five-minute cache is replaced, with a 50-page (100 items per page) bound per media+type. Incomplete reads do not expose a partial list, and Incognito mode blocks reads+and writes. Explicit 401 responses refresh once; uncertain write failures are not+retried. The Trakt domain/data/catalog test suites pass (18/65/46 tests), and+`:app:assembleDebug` succeeds. No real-account watchlist item was changed. Display,+add/remove, failure feedback, and reconnect behavior still need device acceptance+with a configured movie/show catalog.+The five watchlist action/status strings are translated across the catalog's supported locales; :feature:catalog:lintDebug and :data:lintDebug pass (18 existing data lint baseline findings remain filtered).++Local validation passed: 16 Trakt tests, 17 related Settings tests, app Kotlin+compilation, settings dependency boundary verification, and app/data debug lint+against the existing baselines. The configured debug APK built and installed, and+`pm get-app-links` reports `davidona.github.io: verified`. At that checkpoint,+emulator OAuth login and session persistence passed; playback had not yet been tested.+Detailed local command output is in+`build/trakt-final-validation.log` and `build/trakt-configured-build.log`.++Phase 1 follow-up adds an actionable missing-browser message with pending-login+cancellation and retry, plus HTTP/encrypted-storage integration coverage for login+after recreation, saved profile/session, token rotation, disconnect, denial and late+callbacks. These local tests pass. Real login, callback, profile, and session+persistence also passed. The opt-in device test rotated a real token pair once,+verified encrypted persistence, and reloaded the same profile without another+refresh. Output is in `build/trakt-live-refresh-validation.log`. Disconnect showed+Disconnected on the real device. Real deny/cancel, process death during pending+login, and stale callbacks remain browser acceptance checks. An isolated Android+device test with production encrypted storage and synthetic OAuth responses passed+pending-login service/store recreation, denial, cancellation, disconnect, and late+callback rejection. It leaves the real account session untouched; this establishes+device storage/service behavior, not end-to-end browser consent. Output is in+`build/trakt-device-recovery-validation.log`.+Follow-up build/test/lint output is in `build/trakt-phase1-followup-validation.log`.++Device validation found and fixed unreadable status text and a search-result focus+target that prevented the Connect button from receiving focus. The corrected screen+is readable, opens with Connect focused, and launches Firefox. The updated APK build,+17 related Settings tests, and app lint passed; output is in+`build/trakt-device-ui-validation.log`.++The Trakt worktree now uses Room schema 81. Codex_Trakt was upgraded in place from+schema 78; its provider and catalog rows were preserved. The separate default+checkout has advanced to schema 82, so reconcile its newer database changes before+merging or release validation. Code remains uncommitted and unpushed in this+worktree; do not push until requested.++A GitHub Pages hosting package is saved in `docs/trakt-pages/` with release,+beta, and debug App Link associations. The release fingerprint was verified against+the existing signed release APK. The intended callback is+`https://davidona.github.io/oauth/trakt/callback/index.html`; both this page and the+domain-root verification JSON return HTTP 200 without redirects. The hosting site+was published before the user's instruction to keep further code local. Integration+code remains uncommitted and unpushed in this worktree; do not push until requested.+See [TRAKT_PAGES_DEPLOYMENT.md](TRAKT_PAGES_DEPLOYMENT.md).++---++## 1. Executive decision++StreamVault should integrate Trakt as **one registered Trakt application** with a single StreamVault **Client ID**.++Users should **not** enter their Trakt username/password into StreamVault and should **not** create their own Trakt developer application.++For Android, StreamVault should use:++**OAuth 2.0 Authorization Code Flow + PKCE (`S256`) + HTTPS Verified App Link**++This is Trakt's current recommended authentication method for mobile apps.++### Architecture++```text+ Trakt+ │+ StreamVault App+ Client ID+ │+ ┌────────────────┼────────────────┐+ │ │ │+ User A User B User C+ │ │ │+ OAuth OAuth OAuth+ │ │ │+ Access/Refresh Access/Refresh Access/Refresh+ tokens tokens tokens+ │ │ │+ Personal Trakt Personal Trakt Personal Trakt+ account account account+```++The **Client ID identifies StreamVault**.++Each user's **OAuth access token identifies and authorizes that individual user**.++---++# 2. Important 2026 Trakt changes++Trakt's authentication guidance has changed significantly.++## PKCE is now the recommended sign-in mechanism++Trakt explicitly recommends PKCE for the Authorization Code Flow.++A mobile application no longer needs to ship a Trakt `client_secret`.++Trakt states that the Client Secret is **deprecated for user sign-in** and should only be used in situations where it can remain on a trusted server.++For StreamVault:++```text+Use:+client_id+OAuth Authorization Code Flow+PKCE S256+HTTPS redirect URI+Android Verified App Link++Do NOT ship:+client_secret+```++This is especially suitable for StreamVault because the project is open source and distributed as an Android application.++---++## Client ID is public++Trakt explicitly describes the `client_id` as public.++It appears in OAuth authorization requests and therefore cannot be treated as a secret.++It is fine to keep the Client ID in a GitHub Actions secret for repository/configuration hygiene, but this does **not** provide real secrecy.++For example:++```text+GitHub Actions Secret+TRAKT_CLIENT_ID=...++ ↓ build++BuildConfig.TRAKT_CLIENT_ID++ ↓++StreamVault APK+```++Anyone sufficiently motivated can obtain the Client ID from the application or OAuth traffic.++That is expected.++### Recommendation++Use a GitHub secret if convenient, but document internally that:++> `TRAKT_CLIENT_ID` is configuration, not a credential that must remain secret.++Never place a Trakt `client_secret` in the APK.++---++# 3. Trakt application registration++Create **one Trakt API application for StreamVault**.++Current Trakt documentation says creating an application requires a **verified GitHub account** connected through the developer panel.++Developer applications are managed here:++https://developer.trakt.tv/apps++Suggested application identity:++```text+Name: StreamVault+Description: Open-source IPTV and media player with optional Trakt account integration.+```++Use StreamVault's real project/site information where Trakt requests it.++Trakt also requires developers to follow its branding requirements and developer announcements.++---++# 4. Self-hosted / open-source status++Trakt's current API Use Policy explicitly lists these as permitted examples:++- media player integrations that scrobble playback into a connected user's account;+- personal tools;+- self-hosted tools that synchronize a user's own media activity;+- applications that manage a user's watch history, ratings, or lists.++The policy also states that an application's popularity, where it runs, or whether it has a backend does not by itself determine whether the integration is permitted.++This makes StreamVault's architecture a direct fit for Trakt's permitted use cases.++## Important restrictions++StreamVault must not:++- scrape the Trakt website;+- mirror or bulk-harvest Trakt's database;+- sell or redistribute Trakt API data as a dataset/feed;+- provide another service access through StreamVault's Trakt credentials;+- create replacement API apps to evade limits or restrictions;+- use Trakt data in an application that promotes copyright infringement or piracy.++StreamVault should continue to present itself as a **media/IPTV player for user-provided sources**, not as a provider of unauthorized media.++---++# 5. User experience++The user-facing flow should be simple.++## Settings++```text+Settings+└── Trakt+ └── Connect Trakt+```++When the user presses **Connect Trakt**:++```text+StreamVault+ │+ │ Generate PKCE verifier + challenge+ ▼+Open Trakt authorization page in browser+ │+ ▼+User signs into Trakt+ │+ ▼+User approves StreamVault+ │+ ▼+Trakt redirects to StreamVault HTTPS callback+ │+ ▼+Android Verified App Link opens StreamVault+ │+ ▼+StreamVault exchanges authorization code + PKCE verifier+ │+ ▼+Access token + refresh token stored securely+```++After connection:++```text+Trakt++✓ Connected++Automatically track playback ON+Sync watch history ON+Sync watchlist ON++[ Sync Now ]+[ Disconnect ]+```++If desired, StreamVault can fetch the user's Trakt profile after authentication and display their username.++---++# 6. OAuth protocol++## 6.1 Generate a PKCE verifier++For every sign-in attempt, generate a new random `code_verifier`.++Trakt currently specifies:++- length: **43–128 characters**+- allowed characters:+ - `A-Z`+ - `a-z`+ - `0-9`+ - `-._~`++The verifier exists only for the current authentication attempt.++Do not reuse it.++---++## 6.2 Generate the PKCE challenge++Hash the verifier using SHA-256:++```text+SHA256(code_verifier)+```++Then Base64URL encode the result **without padding**.++```text+code_challenge = BASE64URL_NO_PADDING(SHA256(code_verifier))+```++Trakt currently supports:++```text+code_challenge_method=S256+```++Use `S256`.++---++## 6.3 Open Trakt authorization++Open Trakt's authorization endpoint in the user's browser:++```text+https://auth.trakt.tv/oauth/authorize+```++Include the required OAuth parameters plus:++```text+client_id+redirect_uri+response_type=code+state+code_challenge+code_challenge_method=S256+```++`state` should be a cryptographically random value associated with the pending login attempt.++When the callback returns, StreamVault must verify that the returned `state` matches the original value.++If it does not match, abort the login.++---++# 7. Android redirect handling++Trakt's current PKCE documentation specifically recommends **HTTPS redirect URIs**.++For Android, use a **Verified App Link**.++Example conceptual redirect:++```text+https://streamvault.example.com/oauth/trakt/callback+```++That HTTPS URL is registered with Trakt.++Android is configured so that the verified domain opens StreamVault for that callback.++Do **not** use:++```text+streamvault://callback+localhost+urn:ietf:wg:oauth:2.0:oob+```++Trakt now advises against custom schemes and localhost-style callbacks because another application may be able to claim/intercept them.++### Requirement++The `redirect_uri` is case-sensitive and must match exactly:++1. the URI registered in the Trakt developer application;+2. the URI sent in `/oauth/authorize`;+3. the URI sent during token exchange.++---++# 8. Authorization code exchange++After authorization, Trakt redirects back with:++```text+?code=...+&state=...+```++Verify `state`.++Then exchange the temporary authorization code using:++```text+POST /oauth/token+```++Send the authorization code and the original `code_verifier`.++With PKCE:++```text+DO NOT send client_secret+```++The result includes an OAuth access token and refresh token.++---++# 9. Token lifecycle++## Access token++Current Trakt documentation states that access tokens are valid for:++**7 days**++Store the access token securely on the device.++Use it for authenticated Trakt calls:++```http+Authorization: Bearer <access_token>+```++---++## Refresh token++Use the refresh token to obtain a new access token without forcing the user to log in again.++Important 2026 behavior:++**Refresh tokens are single-use.**++Every successful refresh returns:++```text+new access_token+new refresh_token+```++The refresh token that was just used becomes invalid immediately.++Therefore token persistence must behave atomically:++```text+1. Send old refresh token+2. Receive new access token + new refresh token+3. Replace BOTH stored tokens+4. Never use the old refresh token again+```++### Avoid concurrent refreshes++Do not let several API requests independently refresh an expired token.++Use a synchronization mechanism such as a mutex/single-flight token refresh.++Otherwise:++```text+Request A uses refresh_token X → succeeds → X invalidated+Request B uses refresh_token X → fails+```++---++## Legacy token migration++Trakt notes that refresh tokens issued before its recent authentication migration may no longer be exchangeable.++If token refresh returns something equivalent to:++```json+{+ "error": "invalid_grant",+ "error_description": "session not found"+}+```++StreamVault should:++1. clear the invalid local Trakt session;+2. show that Trakt needs to be reconnected;+3. let the user perform OAuth again.++This should be treated as a one-time migration/re-authentication case rather than endlessly retrying the same refresh token.++---++# 10. API request authentication++Trakt says all applications should send the required Trakt API headers, including the app's API key / Client ID.++Authenticated calls additionally use the user's Bearer token.++Conceptually:++```http+trakt-api-key: <STREAMVAULT_CLIENT_ID>+Authorization: Bearer <USER_ACCESS_TOKEN>+```++Implement the remaining version/content headers according to the current endpoint documentation when building the HTTP client.++Centralize these headers in the Trakt API client rather than manually adding them in individual features.++---++# 11. Public vs authenticated requests++Some Trakt endpoints are public and need only the StreamVault Client ID.++Other endpoints require an authenticated user's OAuth token.++Some public endpoints optionally accept OAuth and return personalized information.++Architecture:++```text+Public Trakt request+ ↓+Client ID+ ↓+Trakt+++User-specific request+ ↓+Client ID++ Bearer access token+ ↓+Trakt+```++If a signed-in user's token can validly be supplied to an endpoint, doing so also affects which rate-limit bucket is used.++---++# 12. Current rate limits++As of the current Trakt documentation:++| Scope | Operations | Limit |+|---|---|---:|+| Authenticated user | GET | 500 requests / 5 minutes |+| Authenticated user | POST / PUT / DELETE | 1 request / second |+| Unauthenticated | GET | 500 requests / 5 minutes |++Unauthenticated GET requests are currently scoped by:++```text+Client ID + public IP+```++So devices behind the same public IP can share the unauthenticated allowance.++Authenticated GET requests use the individual user's authenticated bucket.++---++## 429 handling++On:++```http+429 Too Many Requests+```++StreamVault should:++1. inspect `Retry-After`;+2. wait at least that duration when present;+3. otherwise use bounded exponential backoff with jitter;+4. avoid immediate retry loops;+5. cache and de-duplicate requests where appropriate.++Trakt may also return an `X-Ratelimit` header containing diagnostic information.++Log:++```text+HTTP status+endpoint+HTTP method+authenticated vs unauthenticated+Retry-After+X-Ratelimit+```++Do not log OAuth tokens.++---++# 13. What "scrobbling" means++Trakt defines **scrobbling** as automatically tracking playback by reporting when a movie or episode:++```text+starts+pauses+stops+```++This is the correct Trakt feature for StreamVault's playback integration.++Conceptually:++```text+Player starts movie+ ↓+Trakt scrobble: start++Player pauses+ ↓+Trakt scrobble: pause++Player resumes+ ↓+Trakt scrobble: start/resume as required by endpoint semantics++Player stops / completes+ ↓+Trakt scrobble: stop+```++Implementation should follow the exact current scrobble endpoint payload requirements rather than inventing a custom watched-state protocol.++---++# 14. Media identification++Scrobbling is only reliable when StreamVault knows exactly what title the user is playing.++Do not rely only on the filename/title string if stronger metadata exists.++Prefer IDs already attached to StreamVault content.++Useful identifiers in Trakt media objects include IDs such as:++```text+Trakt+TMDB+IMDB+TVDB (where applicable)+```++For a TV episode, the local media model should ideally identify:++```text+Show ID+Season+Episode+```++Example:++```text+StreamVault item+TMDB show ID: 1396+Season: 2+Episode: 3++ ↓++Resolve/match Trakt episode+ ↓++Scrobble exact episode+```++If StreamVault cannot confidently identify the movie/episode, do not silently scrobble the wrong title.++A future fallback may allow the user to manually match an unidentified item.++---++# 15. Recommended StreamVault Trakt features++## Phase 1 — Authentication foundation++Implement:++- Trakt Client ID configuration;+- OAuth Authorization Code Flow;+- PKCE S256;+- random OAuth `state`;+- HTTPS redirect;+- Android Verified App Link;+- access-token storage;+- refresh-token storage;+- single-use refresh rotation;+- disconnect/revoke-local-session behavior;+- user profile/status display.++Deliverable:++```text+Settings → Trakt → Connect+```++works reliably.++---++## Phase 2 — Scrobbling++Implement playback tracking for:++- movie start;+- episode start;+- pause;+- resume;+- stop;+- completion.++Build scrobbling around the central media identity model, not directly around raw IPTV/file names.++Include protection against:++- duplicate start events;+- pause-event spam;+- retry loops;+- scrobbling the wrong episode;+- stale events after the player changes media.++---++## Phase 3 — Watch history synchronization++Add:++- fetch user's Trakt history;+- mark local items as watched based on Trakt state;+- send explicitly watched local items to Trakt where appropriate;+- "Sync Now" action.++Define conflict behavior before implementing two-way sync.++Recommended principle:++```text+Do not erase either side automatically unless the user explicitly performs+an action whose meaning is unambiguous.+```++---++## Phase 4 — Watchlist++**Implementation status:** code complete; real-account device acceptance remains open.++Add optional support for:++- reading the user's Trakt watchlist;+- showing whether a StreamVault movie/show is on the watchlist;+- add/remove watchlist actions.++The home dashboard also offers optional **Trakt Watchlist Movies** and **Trakt+Watchlist Series** shelves. They preserve Trakt's list order, resolve only against+the active provider by TMDB ID, and omit titles without a playable catalog match.+The shelves are separate from StreamVault's local Favorites. The Movies and+Series sections also expose a Trakt Watchlist action in shelf mode and a+watchlist category in the category picker; Classic mode shows it as another+clickable category. These views use targeted provider/TMDB lookups, preserve+Trakt order, and explain when no watchlisted titles match the current provider+or filters.++Keep this separate from playback history.++---++## Phase 5 — Additional Trakt functionality++**Implementation status:** the first Phase 5 slice is implemented in code: the+existing movie/show heart continues to save to StreamVault Favorites and, when+Trakt is connected, adds or removes that TMDB-matched movie/show in Trakt+Favorites. A failed remote write leaves the local change intact and reports the+sync failure. This applies to detail, search, and saved-item heart actions;+group-only changes and live-channel favorites remain local. Items without a+TMDB ID remain local-only. Existing local favorites are not bulk-uploaded, and+an explicit provider-scoped import action adds existing Trakt Favorites when an+exact TMDB match is present in the active provider's catalog.++The ratings slice is also implemented. Movie and show detail pages read the+connected account's ratings from Trakt, stage each read before replacing its+account-scoped cache, and keep the cache for five minutes. Reads are bounded to+50 pages of 100 items per media type; missing or invalid TMDB IDs and malformed+ratings are skipped. The current Trakt rating appears in the rating dialog, where+the user can submit a value from 1 to 10, and on the detail page beside the title+metadata when a rating exists. Writes use the exact TMDB ID, share the+account service's serialized token refresh, retry once only after an explicit 401,+and are never retried after an ambiguous transport failure. Incognito mode blocks+rating reads and writes. Ratings do not replace provider ratings or external rating+metadata, and episodes are not included. Local unit/API tests cover read pagination,+staging, cache behavior, write payloads, account changes, incognito, and detail-page+identity mapping. Real-account rating UI acceptance remains open; no live rating was+submitted during implementation.++Discovery/trending (October 16): Movies and Series expose **Trending on Trakt** and+**Popular on Trakt** in modern shelf browsing and classic category browsing. These+public endpoints do not require a Trakt sign-in. StreamVault caches each first page+for 30 minutes, preserves Trakt order, and shows only exact TMDB matches from the+active provider, so discovery never imports a remote catalog into the app. Failed+refreshes retain the last good page and surface an error state. API parsing, cache,+and catalog-order projection have focused tests. On October 16, debug version+1.0.19 was installed on the Codex_Trakt Android 16 emulator; Trending on Trakt+and Popular on Trakt each loaded provider-matched results in both Movies and+Series. The Classic-mode category rail still needs device acceptance.++Discovery visibility settings (October 16): Settings → Movies & Series → Library+browsing now has four independent switches for Trending and Popular in Movies and+Series. All four default to visible and persist with the rest of user preferences.+Turning one off removes it from the modern browse actions, category picker, and+Classic category rail; if that category was selected, the view returns to the full+library. The preferences are included in portable backup classification. The+switches are visible on the Codex_Trakt emulator. Hiding and restoring Trending+movies was verified in modern browsing: the action disappears and returns while+Popular remains. Classic-mode rail acceptance remains open.++Emulator compatibility (October 16): The Trakt AVD's database was at schema 78,+with an older schema-80 layout also present on a second development AVD. A+data-preserving 80→81 repair migration aligns the episode index and Xtream+onboarding receipt columns. The historical Room migration suite passed on+Codex_Trakt, and the app opened after upgrade with the existing provider and catalog+rows preserved. No app data was cleared.++Phase 5 account controls and import (October 16): Settings exposes persistent+switches for playback scrobbling and manual history import/upload. Disabling+scrobbling pauses an already active Trakt playback session so it cannot create a+watched-history stop, hides the player tracking status, and suppresses queued new+starts. Disabling history sync prevents the manual sync action from running. An+explicit **Import Trakt favorites to this provider** action reads Trakt movie/show+favorites in bounded pages, stages the complete read before local writes, and adds+only exact TMDB matches from the active provider to StreamVault Favorites. The+result reports added, already present, unmatched, and skipped titles; it never+uploads existing local favorites. The profile now displays available name,+location, joined date, gender, age, VIP status, and about text, with a refresh+action. It does not hotlink Trakt-hosted avatars. Favorite import, settings,+profile parsing, and scrobbling preference behavior have focused unit coverage;+the debug APK assembles successfully. Version 1.0.19-debug was installed in place+and launched on the Codex_Trakt Android 16 emulator; provider, catalog, and account+data were retained. Real-account import and toggle acceptance remain open.++Still deferred or unvalidated:++- Cast/external-player playback scrobbling and manual matching for unknown media.+- Custom-list people items and real-account acceptance for deletion/reordering and+ season/episode add/remove operations.+- Real-account acceptance for history sync, watchlist, Favorites import, ratings,+ and custom-list operations.++Authentication, matching, scrobbling, history sync, watchlist, personal lists with+movie/show/season/episode support, list deletion and ordering, movie/show Favorites,+movie/show ratings, and public trending/popular+categories, Favorites import, and expanded text profile are implemented;+real-account acceptance remains open for the operations listed above.++---++# 16. Suggested internal module design++```text+Trakt/+├── TraktApiClient+├── TraktAuthService+├── TraktTokenStore+├── TraktTokenRefreshCoordinator+├── TraktScrobbleService+├── TraktSyncService+├── TraktMediaMatcher+└── Models/+```++## TraktApiClient++Responsibilities:++- base URL;+- required headers;+- Client ID;+- Bearer token injection;+- JSON serialization;+- HTTP response handling;+- rate-limit metadata.++Do not place OAuth UI logic here.++---++## TraktAuthService++Responsibilities:++- generate PKCE verifier/challenge;+- generate and validate `state`;+- construct authorization URL;+- process callback;+- exchange authorization code;+- refresh token;+- disconnect.++---++## TraktTokenStore++Responsibilities:++- securely persist:+ - access token;+ - refresh token;+ - token expiry information;+- atomically replace tokens after refresh;+- clear tokens on disconnect/re-authentication requirement.++---++## TraktTokenRefreshCoordinator++Responsibilities:++- ensure only one token refresh occurs at a time;+- let waiting requests reuse the newly refreshed token;+- prevent reuse of an invalidated single-use refresh token.++---++## TraktMediaMatcher++Responsibilities:++Resolve the currently playing StreamVault item to an exact Trakt movie/episode using authoritative media IDs whenever possible.++This module is deliberately independent from the player.++---++## TraktScrobbleService++Responsibilities:++Translate player lifecycle events into Trakt scrobble requests.++It should not be responsible for identifying media.++Input should already be something like:++```text+ResolvedTraktMovie+or+ResolvedTraktEpisode+```++---++# 17. GitHub / build configuration++Recommended:++```text+GitHub repository+ │+ ├── no Trakt client secret+ │+ └── workflow reads TRAKT_CLIENT_ID+ │+ ▼+ Android build+ │+ ▼+ BuildConfig.TRAKT_CLIENT_ID+```++Keeping the Client ID in GitHub Actions Secrets is acceptable for convenience.++However:++**Do not build security assumptions around hiding the Client ID.**++PKCE is what protects OAuth sign-in when the client itself cannot keep a secret.++---++# 18. Local token security++The following are real user credentials and must be protected:++```text+access_token+refresh_token+```++Do not:++- commit them to Git;+- include them in crash reports;+- write them to normal application logs;+- put them into analytics payloads;+- expose them in UI/debug screens in release builds.++Use Android secure storage appropriate to StreamVault's architecture.++The Client ID does not require this secrecy.++---++# 19. Trakt image handling++If StreamVault later uses images returned directly by Trakt:++Trakt currently requires applications to **cache the images** rather than hotlink them from Trakt's CDN.++Its current image guidance says image data can be included with:++```text+?extended=full+```++and images are returned in WebP form.++Do not add Trakt image support by simply pointing permanent UI image URLs at Trakt's CDN.++If StreamVault already uses TMDB or another media metadata provider for artwork, keeping artwork responsibility with that provider may be cleaner.++---++# 20. Pagination and API efficiency++For paginated Trakt endpoints:++```text+?page=...+&limit=...+```++Trakt recommends explicitly sending pagination parameters when supported.++Do not assume a universal page size.++Use response headers such as:++```text+X-Pagination-Page+X-Pagination-Limit+X-Pagination-Page-Count+X-Pagination-Item-Count+```++Use these values instead of calculating page count from the requested limit.++Cache API data where appropriate and avoid repeatedly requesting data StreamVault already has.++---++# 21. API application lifecycle++A noteworthy current policy:++Trakt says API application registrations may be automatically deleted after **30 consecutive days with no usage**.++Registrations used only for testing during their first 30 days may also be removed.++Therefore:++- create the real StreamVault integration when implementation work is active;+- keep developer account/contact information current;+- do not create unnecessary duplicate apps.++---++# 22. Failure handling++StreamVault should explicitly handle:++## Authentication cancelled++User closes browser or denies access:++```text+Keep Trakt disconnected.+Do not show an application error.+```++## OAuth state mismatch++```text+Abort login immediately.+Discard pending PKCE transaction.+```++## Expired access token++```text+Refresh once through TraktTokenRefreshCoordinator.+Retry original operation after successful refresh.+```++## Refresh `invalid_grant`++Especially:++```text+session not found+```++Treat as requiring reconnection.++Do not repeatedly retry.++## 401 after refresh++Clear invalid session and request reconnection.++## 429++Respect `Retry-After`.++## Offline++Queue only operations where delayed execution has clear semantics.++Do not create an unbounded playback-event queue.++## Unknown media identity++Do not scrobble until a reliable match exists.++---++# 23. Recommended implementation order++```text+1. Register StreamVault Trakt app+ ↓+2. Configure Client ID+ ↓+3. Configure HTTPS redirect + Android App Link+ ↓+4. Implement PKCE + OAuth state+ ↓+5. Implement callback + token exchange+ ↓+6. Secure token persistence+ ↓+7. Single-flight token refresh+ ↓+8. Connected-account settings UI+ ↓+9. Media ID matching+ ↓+10. Playback scrobbling+ ↓+11. History synchronization+ ↓+12. Watchlist support+ ↓+13. Optional ratings/lists/discovery+```++Do not start history/watchlist synchronization before authentication and media matching are reliable.++---++# 24. Acceptance checklist++## Registration++- [ ] StreamVault Trakt developer application created.+- [ ] Developer GitHub account verified/connected if required by Trakt.+- [ ] Client ID configured.+- [ ] No Client Secret included in StreamVault.++## OAuth++- [ ] Authorization Code Flow implemented.+- [ ] PKCE verifier generated per login.+- [ ] PKCE uses SHA-256 / `S256`.+- [ ] OAuth `state` generated and validated.+- [ ] HTTPS callback registered.+- [ ] Android Verified App Link configured.+- [ ] Redirect URI matches exactly in all OAuth stages.+- [ ] Browser-based Trakt login works.++## Tokens++- [ ] Access token securely stored.+- [ ] Refresh token securely stored.+- [ ] 7-day access-token expiry handled.+- [ ] Refresh token rotation replaces both tokens.+- [ ] Concurrent refresh is prevented.+- [ ] `invalid_grant` migration case prompts reconnect.+- [ ] Tokens are never logged.++## API++- [ ] Client ID header centrally added.+- [ ] Bearer token centrally added for authenticated calls.+- [ ] 401 handling implemented.+- [ ] 429 handling respects `Retry-After`.+- [ ] Request caching/de-duplication implemented where useful.+- [ ] Pagination response headers handled correctly.++## Playback++- [ ] Movie matching works.+- [ ] Show/season/episode matching works.+- [ ] Start scrobble works.+- [ ] Pause scrobble works.+- [ ] Stop/completion scrobble works.+- [ ] Duplicate playback events suppressed.+- [ ] Unknown media does not get incorrectly scrobbled.++## User experience++- [ ] Connect Trakt button.+- [ ] Browser authentication.+- [ ] Return to StreamVault automatically.+- [ ] Connected state visible.+- [ ] Disconnect option.+- [ ] Scrobbling toggle.+- [ ] History-sync toggle.+- [ ] Watchlist-sync toggle if implemented.+- [x] Read and set Trakt movie/show ratings from detail pages.++---++# 25. Things StreamVault should explicitly NOT do++```text+✗ Ask for the user's Trakt password+✗ Store a Trakt password+✗ Embed a client_secret in Android+✗ Require every StreamVault user to create a developer application+✗ Use replacement API keys to bypass restrictions+✗ Scrape trakt.tv+✗ Mirror the Trakt catalog+✗ Redistribute Trakt's dataset+✗ Hotlink Trakt-hosted artwork+✗ Treat the Client ID as a true secret+✗ Reuse old refresh tokens after a successful refresh+✗ Use custom-scheme OAuth callbacks when the recommended verified HTTPS App Link can be used+```++---++# 26. Sources++All core decisions in this plan are based on Trakt's official developer documentation.++## Trakt API introduction++https://developer.trakt.tv/++Covers Trakt terminology including scrobble, history, watchlist, lists and favorites.++---++## Authentication / OAuth++https://developer.trakt.tv/docs/authentication-oauth++Key findings:++- OAuth 2.0 is used for account authorization.+- Authorization Code Flow is intended for apps with browser/callback support.+- Device Code Flow is intended for TVs/media centers/limited-input devices.+- PKCE is recommended.+- Access tokens are currently valid for 7 days.+- Refresh tokens are single-use.+- Older refresh tokens affected by the authentication migration may require users to reconnect.++---++## PKCE++https://developer.trakt.tv/docs/pkce++Key findings:++- PKCE is recommended for apps that sign users in.+- Trakt only supports `S256`.+- `client_id` is public.+- A `client_secret` is not required for PKCE login.+- Client Secret is deprecated for user sign-in.+- Android should use HTTPS Verified App Links.+- Custom schemes, localhost and out-of-band callbacks are discouraged.++---++## Create a Trakt application++https://developer.trakt.tv/docs/create-an-app++Key findings:++- New apps use a Client ID.+- PKCE does not require a Client Secret.+- A verified GitHub account is currently required to create an API app.+- Developers must follow Trakt's API/branding rules.+- Trakt data must not be used in applications promoting copyright infringement or piracy.++App management:++https://developer.trakt.tv/apps++---++## API use policy++https://developer.trakt.tv/docs/api-use-policy++Key findings:++- media-player scrobbling is explicitly permitted;+- personal/self-hosted tools are explicitly permitted;+- app popularity/location/backend does not itself decide permission;+- bulk harvesting, resale and dataset redistribution are prohibited;+- rate-limit circumvention is prohibited;+- API app registrations can be removed after 30 consecutive days without usage;+- applications should provide clear privacy information for their own handling of user data.++Policy page was updated by Trakt in September 2026.++---++## Rate limits++https://developer.trakt.tv/docs/rate-limiting++Current documented limits:++```text+Authenticated GET:+500 / 5 minutes / user++Authenticated POST/PUT/DELETE:+1 / second / user++Unauthenticated GET:+500 / 5 minutes / Client ID + public IP+```++Also documents:++```text+429 Too Many Requests+Retry-After+X-Ratelimit+```++---++## Pagination++https://developer.trakt.tv/docs/pagination++Documents:++```text+page+limit+X-Pagination-Page+X-Pagination-Limit+X-Pagination-Page-Count+X-Pagination-Item-Count+```++Page sizes vary by endpoint and should not be assumed globally.++---++## Extended information++https://developer.trakt.tv/docs/extended-info++Trakt returns minimal media information by default and supports extended data where required.++Prefer requesting only the amount of data StreamVault actually needs.++---++## Images++https://developer.trakt.tv/docs/images++Important:++- Trakt-hosted images must be cached;+- hotlinking is not allowed;+- `extended=full` is the current preferred way to request image information where supported;+- images are currently returned as WebP URLs.++---++# 27. Final StreamVault decision++For StreamVault Android:++```text+ONE StreamVault Trakt application+ONE public Client ID+NO client secret in the app++OAuth 2.0 Authorization Code++ PKCE S256++ HTTPS callback++ Android Verified App Link++Each user:+ own access token+ own rotating refresh token+ own Trakt account+ own authenticated rate-limit bucket++Playback:+ resolve exact movie/episode+ → scrobble start/pause/stop++Later:+ history+ watchlist+ ratings/lists if useful+```++This should be treated as the baseline Trakt architecture unless Trakt changes its developer documentation again.diff --git a/docs/TRAKT_HISTORY_SYNC.md b/docs/TRAKT_HISTORY_SYNC.mdnew file mode 100644index 00000000..7c9b0324--- /dev/null+++ b/docs/TRAKT_HISTORY_SYNC.md@@ -0,0 +1,86 @@+# Trakt history synchronization++## Current implementation — October 12, 2026++The authenticated read API fetches one mixed history page at a time, with a limit of+100 rows. It shares the account mutex and single-use token rotation with playback+and profile requests. A 401 can trigger one refresh; a second 401 requires reconnect.+Rate-limited reads return a status without retrying. Missing pagination headers use+the raw row count, so skipped malformed rows do not prematurely end pagination.++Movie entries require a positive TMDB movie ID. Episode entries require a positive+parent-show TMDB ID and exact season/episode numbers. Unsupported or malformed rows+are counted and skipped. History IDs retain 64-bit integer precision. The endpoint+and response format were checked against the+[official Trakt sync contract](https://github.com/trakt/trakt-api/blob/master/projects/api/src/contracts/sync/index.ts).++The matching index deduplicates repeated history IDs across pages. Conflicting+identities for the same history ID match neither item. It reports the latest watch+and distinct play count for each exact media identity.++## Merge policy++- Import candidates must match a catalog-resolved media identity and content kind;+ episodes must also match the local season and episode numbers.+- Newer local rewatch progress and explicit manual completion are preserved.+- Imported completion is automatic completion, with the newer watch timestamp and+ the larger play count. Older progress advances to the known duration so existing+ library queries reflect completion. Newer local rewatch progress, metadata, and+ provider identity remain intact.+- Applying the same match twice produces no second candidate.+- An item absent from remote history produces no change. Nothing is deleted or+ marked unwatched automatically.++The policy returns candidates. A dedicated repository operation rechecks current+persisted/pending history under its lock and in a Room transaction before applying+one candidate and updating catalog projections. It assigns automatic completion,+preserves the remote watch timestamp, and never increments the play count merely+because a sync was repeated. Current incognito preferences suppress writes.+Completed episodes are excluded from unwatched counts even with unknown duration.+No real account history was fetched or changed by automated validation.++## Manual Sync Now++Settings → Trakt → Sync Now stages the entire bounded remote read first (up to 50+pages / 5,000 records). A failed page or exceeded limit produces no writes. Movie/show+catalog lookup uses bounded TMDB batches; episode matching uses cached exact+provider/series ownership and season/episode numbers. It does not fetch provider+catalogs or guess titles.++Account changes stop the run. Local import failure may leave earlier successful+imports; the UI reports that count, and retrying is idempotent. The result includes+imported, uploaded, unchanged, unmatched, and skipped counts. Outbound sync uses the+newest completed local event per exact media identity, skips events already present+in Trakt, and sends batches of at most 100. Repeated Sync Now runs reconcile against+Trakt history before another POST; uploads are never automatic. Incognito mode blocks+the operation. Ambiguous write failures stop the run, and the next manual run reads+history before deciding what remains. There is no automatic polling or history+deletion. Local history stores only each item's latest watch time, so older local+rewatches cannot be reconstructed as separate dated events.++## Remaining work++The authenticated empty-history Sync Now path passed on the isolated Codex_Trakt+emulator. The connected account returned a successful result with zero imported,+uploaded, unchanged, unmatched, or skipped items. The emulator had no provider/catalog,+so this did not exercise media matching or outbound upload and changed no Trakt history.+Still verify a non-empty account and library, including rewatch/manual completion+conflicts, repeated sync, and interruption. Larger histories need a bounded+continuation design before expanding the current read limit.++Trakt now normalizes `watched_at` to minute precision and its API team says the same+item plus minute timestamp deduplicates naturally, though the current history contract+still has an older warning assigning duplicate prevention to clients. StreamVault+therefore canonicalizes uploads to UTC minute timestamps and preflights all staged+history before writing. A capped or failed read still blocks every upload.++Local test/build/lint output: `build/trakt-history-import-final-validation.log`. Tests cover+mixed pages, pagination, malformed rows, duplicate/conflicting IDs, merge conflicts,+401/rate-limit handling, history/playback sharing one token rotation, staged-read+failures/limits, account switches, incognito, idempotent transactional persistence,+catalog progress, episode counts, and the manual settings action. The outbound follow-up+adds MockWebServer payload/response tests and service coverage for exact movie/episode+resolution, minute-precision reconciliation, the 100-event cap, incognito and account+changes, refresh retry, and ambiguous failure handling. All 52 Trakt data tests and 18+Trakt domain tests pass locally; these tests do not write to a real Trakt account.+Real-account sync/device acceptance remains open.diff --git a/docs/TRAKT_PAGES_DEPLOYMENT.md b/docs/TRAKT_PAGES_DEPLOYMENT.mdnew file mode 100644index 00000000..f56ea90e--- /dev/null+++ b/docs/TRAKT_PAGES_DEPLOYMENT.md@@ -0,0 +1,87 @@+# Deploy the Trakt callback with GitHub Pages++The files in `docs/trakt-pages/` were published at the root of the GitHub user site+repository `Davidona/davidona.github.io` on October 11, 2026, before the user's+instruction to keep further code local. The integration worktree has not been+pushed. Do not publish further code until the user requests it.++Deployment commit: `17d72f1f9ece8b9b907ad299ed9da481dc6da50c`.+Both public URLs below returned HTTP 200 without redirects and with the expected+content types. Trakt's existing StreamVault app has the exact callback registered;+local debug configuration matches it. The configured APK built and installed, and+Android reports `davidona.github.io: verified` for `com.streamvault.app.debug`.+Real OAuth login/consent and callback delivery passed on the isolated Codex_Trakt+emulator (5558) using Firefox 157.0.1. Connected state and username survived an app+process restart. Remaining account acceptance cases are tracked in TRAKT_SETUP.md.+GitHub Actions callback+variable configuration and integration workflow+changes remain pending publication approval.++## Publish++1. Check whether `Davidona/davidona.github.io` already exists. If it does, preserve+ its existing site and merge only the needed callback and verification files.+2. Otherwise, create a public repository named `davidona.github.io` under Davidona.+3. Copy the **contents** of `docs/trakt-pages/` into the repository root, including+ `.nojekyll` and `.well-known/assetlinks.json`. Commit them on `main`.+4. In repository Settings → Pages, select Deploy from a branch, `main`, and `/ (root)`.+5. Wait for deployment and verify these two addresses return HTTP 200 directly,+ without a redirect:+ - `https://davidona.github.io/.well-known/assetlinks.json` (application/json)+ - `https://davidona.github.io/oauth/trakt/callback/index.html` (text/html)++Use the explicit `index.html` callback URL because directory paths on static hosts+may redirect to add a trailing slash. Register the exact explicit URL everywhere.++## Configure Trakt and builds after deployment++Keep `https://github.com/Davidona/StreamVault-IPTV` in Trakt's **Website** field.+Set Trakt's **Redirect URI** to:++```text+https://davidona.github.io/oauth/trakt/callback/index.html+```++Set the same value in local.properties as `trakt.redirect.uri`, and in GitHub+repository variable `TRAKT_REDIRECT_URI` for the StreamVault build workflows.+Set repository secret `TRAKT_CLIENT_ID` to the supplied public app ID. No client+secret is needed. Local callback configuration is complete. The public Client ID+was also saved as an Actions secret before publication was paused; no client secret+was configured. Add the callback variable when preparing CI for publication.++## Certificates included++The verification file authorizes only these application/certificate combinations:++| Package | Certificate |+| --- | --- |+| `com.streamvault.app` | Existing release APK signing certificate |+| `com.streamvault.app.beta` | Same official certificate used by the beta build configuration |+| `com.streamvault.app.debug` | This machine's debug signing certificate |++The release certificate was confirmed using Android apksigner against the existing+release APK on October 11, 2026. The debug certificate was confirmed with this+worktree's Gradle signingReport. Certificates are public; no keystore/private key,+password, OAuth code, or user token is included. New signing keys require updating+this file. A debug build from another machine may use a different certificate.++## Validate++Install the new debug APK with the configured callback. On Android 12+:++```text+adb shell pm verify-app-links --re-verify com.streamvault.app.debug+adb shell pm get-app-links com.streamvault.app.debug+```++Confirm `davidona.github.io` is verified. A 200 response alone does not prove+Android verification. Complete browser consent from Settings → Trakt and confirm+the app returns with the connected username. Keep one matching StreamVault build+installed during routing tests. Then validate restart, cancellation, disconnect,+and refresh behavior from `TRAKT_SETUP.md`.++The fallback page removes the OAuth query from browser history and neither reads+nor exchanges OAuth codes. Domain verification causes Android to route the link+to the app before the page is loaded. GitHub still receives a normal web request+if the browser loads the fallback page; this static page cannot control hosting+provider logs.diff --git a/docs/TRAKT_SETUP.md b/docs/TRAKT_SETUP.mdnew file mode 100644index 00000000..b291990f--- /dev/null+++ b/docs/TRAKT_SETUP.md@@ -0,0 +1,193 @@+# Trakt setup and validation++Settings → Trakt supports browser sign-in, profile refresh, disconnect, VOD+scrobbling, and manual two-way history sync. Movie/show detail pages support Trakt+watchlist actions and 1–10 user ratings.+The client ID and HTTPS callback configuration below apply to all variants.++## Build configuration++Register one StreamVault application at https://developer.trakt.tv/apps. Set the+public Client ID and an HTTPS callback URI owned by the project using either:++```properties+# local.properties (gitignored)+trakt.client.id=YOUR_PUBLIC_CLIENT_ID+trakt.redirect.uri=https://YOUR_DOMAIN/oauth/trakt/callback+```++Or environment variables `TRAKT_CLIENT_ID` and `TRAKT_REDIRECT_URI`, which take+precedence. These apply to all variants. CI beta/release workflows read repository+secret `TRAKT_CLIENT_ID` and repository variable `TRAKT_REDIRECT_URI`. The Client ID+is public configuration. Do not configure a client secret.++Unconfigured builds show a disabled Connect button. No production domain or Client+ID is invented. The callback must match the registered URI exactly. The manifest+host and path are generated from the same build value as the OAuth requests.+Use a normal HTTPS URI without a port, query, fragment, or embedded user info.++## Verified App Link deployment++Host `https://YOUR_DOMAIN/.well-known/assetlinks.json` over HTTPS, without redirects:++```json+[+ {+ "relation": ["delegate_permission/common.handle_all_urls"],+ "target": {+ "namespace": "android_app",+ "package_name": "com.streamvault.app",+ "sha256_cert_fingerprints": ["YOUR_RELEASE_SIGNING_CERTIFICATE_SHA256"]+ }+ }+]+```++For development/beta testing, add separate entries for `com.streamvault.app.debug`+and `com.streamvault.app.beta` with the corresponding signing certificates. Publish+only variants/certificates you control. Keep only the intended app variant installed+while checking callback routing. Obtain fingerprints with Gradle `:app:signingReport`.++On Android 12+ use `adb shell pm verify-app-links --re-verify PACKAGE`, then+`adb shell pm get-app-links PACKAGE` to confirm the domain is verified. On older+Android versions, inspect domain verification with `adb shell dumpsys package PACKAGE`.+The manifest alone does not establish domain ownership; deployment is required.++### GitHub Website field versus callback++`https://github.com/Davidona/StreamVault-IPTV` is a suitable project Website value+in the Trakt registration form. It is not an Android OAuth callback: StreamVault+cannot publish domain verification files on `github.com`.++A GitHub Pages user site is deployed from the repository `davidona.github.io`. It+serves `https://davidona.github.io/oauth/trakt/callback/index.html`, with verification+at `https://davidona.github.io/.well-known/assetlinks.json`. Both addresses returned+HTTP 200 without redirects on October 11, 2026. A project Pages site under `/StreamVault-IPTV/` does+not provide control of the domain-root `/.well-known/` path required by Android.+Include `.nojekyll` when serving the static verification directory from a branch.++The complete static hosting package is prepared in `docs/trakt-pages/`, including+the verified release signing certificate and this machine's debug certificate.+See [TRAKT_PAGES_DEPLOYMENT.md](TRAKT_PAGES_DEPLOYMENT.md) for deployment status.+The explicit `index.html` callback avoids a directory-slash redirect on static hosts.++References: [GitHub Pages setup](https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-github-pages-site)+and [Android website associations](https://developer.android.com/training/app-links/configure-assetlinks).++## Token and failure behavior++Access/refresh tokens and pending PKCE state are encrypted with the existing+CredentialCrypto implementation and saved as one AtomicFile record in no-backup+storage. Neither tokens nor callback URLs are logged. The existing crypto layer+uses Android Keystore and has an app-private software fallback on broken TV devices.++Login transactions expire after ten minutes and are consumed once, including state+mismatch, duplicate query parameters, denial, or a bad callback path. Valid pending+transactions survive process death while the browser is open.++A mutex serializes account operations and refreshes. Both tokens are replaced+together. Before a refresh, the old session is cleared durably so a crash, network+timeout, or persistence failure cannot reuse a possibly consumed single-use token.+Such failures require reconnecting. This deliberately favors credential safety over+silently retrying an ambiguous refresh. Disconnect clears local tokens and pending+sign-in; it does not revoke the application grant on Trakt's website.+An explicit 429 rejection preserves the old session for retry after cooldown because+the server issued no replacement tokens.++The dedicated HTTP client has no body logger/cache, redirects, or transport retries.+Writes are spaced at least one second apart. A 429 establishes a cooldown from+Retry-After (seconds or HTTP date), or exponential backoff with jitter. Further+requests fail locally during that cooldown; the client does not loop or queue events.++## End-to-end acceptance still required++### Playback tracking implementation (October 12, 2026)++Identified movies and episodes are wired to start, pause/resume, completion, content+switch, and cleanup reporting. Episodes resolve a show TMDB ID and exact numbers to+a Trakt episode ID before posting. Live TV, catch-up, recordings, trailers, unknown+external URLs, cast, and external-player tracking are excluded. Mismatched local+episode ownership is skipped rather than guessed. Tracking sends only for a connected+account, shares token rotation with profile requests, and never retries ambiguous+writes. No real watched-history writes were performed during automated validation.++The current Trakt contract was checked against its official source:+- [Scrobble endpoints](https://github.com/trakt/trakt-api/blob/master/projects/api/src/contracts/scrobble/index.ts)+- [Episode scrobble IDs](https://github.com/trakt/trakt-api/blob/master/projects/api/src/contracts/scrobble/schema/request/episodeScrobbleRequestSchema.ts)+- [External ID lookup](https://github.com/trakt/trakt-api/blob/master/projects/api/src/contracts/search/index.ts)++Real acceptance still needs an identified movie and episode: verify start on Trakt,+pause/resume, completion, switching titles, and disconnect during playback. This is+separate from the successful real account sign-in and token-rotation checks below.++`TraktPlaybackIntegrationTest` covers the production coordinator → account → HTTP+client → encrypted-store path with a synthetic account and local MockWebServer.+It verifies authenticated movie and resolved-episode requests through pause/resume,+switching, and completion. It passed alongside the debug build. Failed/skipped starts+also cannot submit a later stop and accidentally create watched history. These local+checks do not establish real-device VOD playback or backend history acceptance.++The existing StreamVault app registration and local configuration now match the+deployed callback. Android verifies the domain for the installed debug APK. Real+login and consent completed in Firefox 157.0.1 on the isolated Codex_Trakt AVD+(emulator-5558). The callback returned to StreamVault, which displayed Connected+and the account username. Profile refresh completed without an error. Force-stop+and relaunch restored Connected and the same username (old PID 2256, new PID 3115).+No tokens or authorization codes were collected in the validation evidence.++Firefox's login page is difficult to navigate with a TV D-pad. Codex_Trakt uses+`hw.screen=multi-touch` so the host mouse can provide touch input for browser login.+This is an emulator configuration change, not a change to StreamVault's TV input.++The original Television_4K_2 device has database version 81; this worktree uses 78.+Its newer original-checkout APK was restored without clearing data. Use Codex_Trakt+for these checks and reconcile the newer app/database changes before release.+On a device with a real browser:++1. **Passed:** Connect from Settings → Trakt and confirm browser consent returns to StreamVault.+2. **Passed:** Confirm username and connected state, including after app process restart.+3. Deny/cancel consent and confirm the account stays disconnected without an error.+4. Restart the app process while the browser is open and complete the same login.+5. Disconnect and confirm a stale callback cannot reconnect the account.+6. **Passed:** Rotate a real token pair, persist it encrypted, and reload the same+ profile without another refresh. The opt-in device test passed on Codex_Trakt;+ output is in `build/trakt-live-refresh-validation.log`.++The real-device Disconnect action also displayed Disconnected. A new login was+started and the app process stopped while Firefox was open; completing that login+is pending. Browser denial/cancel and stale-callback end-to-end checks remain pending.++`TraktAccountRecoveryInstrumentationTest` passed on Codex_Trakt with production+Android encrypted storage in a separate test directory and synthetic OAuth API+responses. It verifies pending-login recreation, denial, cancellation, disconnect,+and late callback rejection without changing the real account. Output is in+`build/trakt-device-recovery-validation.log`. This does not replace browser handoff+acceptance. The app and Android test APK both built successfully.++`TraktLiveAccountInstrumentationTest` is skipped unless `live_trakt=true` is+explicitly supplied. It uses the isolated device's existing signed-in session and+rotates its real tokens; run it only with the app stopped. A test clock expires the+old pair in memory, and the production service performs the refresh and persistence.+It does not log or export token values. Run the specific test with:++```powershell+adb -s emulator-5558 shell am instrument -w -e class com.streamvault.app.trakt.TraktLiveAccountInstrumentationTest -e live_trakt true com.streamvault.app.debug.test/androidx.test.runner.AndroidJUnitRunner+```++Use the installed Firefox browser on Codex_Trakt for these checks. A+package that only resolves web intents to Android's framework browser stub cannot+complete consent. If there is no handler at all, Settings shows an install-browser+message and clears the pending login so Connect can be tried again.++Unit tests cover PKCE, callback rejection, single-use refresh concurrency/failure,+request headers/payloads, rate-limit cooldown, and encrypted atomic persistence.+Local integration tests also combine the production HTTP client, CredentialCrypto,+and disk store against MockWebServer: complete login after service/store recreation,+reload the username, rotate and persist the token pair, disconnect, and reject late+callbacks after cancellation. Robolectric uses the crypto layer's software fallback;+this does not verify a device's hardware Keystore or browser/App Link handoff.+They do not establish real Trakt sign-in. Domain verification was checked separately+with Android's package manager.++Official protocol references: https://developer.trakt.tv/docs/pkce and+https://developer.trakt.tv/docs/authentication-oauth.diff --git a/docs/trakt-pages/.nojekyll b/docs/trakt-pages/.nojekyllnew file mode 100644index 00000000..8b137891--- /dev/null+++ b/docs/trakt-pages/.nojekyll@@ -0,0 +1 @@+diff --git a/docs/trakt-pages/.well-known/assetlinks.json b/docs/trakt-pages/.well-known/assetlinks.jsonnew file mode 100644index 00000000..e855dda2--- /dev/null+++ b/docs/trakt-pages/.well-known/assetlinks.json@@ -0,0 +1,32 @@+[+ {+ "relation": ["delegate_permission/common.handle_all_urls"],+ "target": {+ "namespace": "android_app",+ "package_name": "com.streamvault.app",+ "sha256_cert_fingerprints": [+ "C2:48:B6:5F:3E:F3:AC:2B:61:C6:B2:1E:61:29:FB:13:96:92:4A:01:5B:6B:EF:21:56:6A:CE:D8:27:BF:4F:4D"+ ]+ }+ },+ {+ "relation": ["delegate_permission/common.handle_all_urls"],+ "target": {+ "namespace": "android_app",+ "package_name": "com.streamvault.app.beta",+ "sha256_cert_fingerprints": [+ "C2:48:B6:5F:3E:F3:AC:2B:61:C6:B2:1E:61:29:FB:13:96:92:4A:01:5B:6B:EF:21:56:6A:CE:D8:27:BF:4F:4D"+ ]+ }+ },+ {+ "relation": ["delegate_permission/common.handle_all_urls"],+ "target": {+ "namespace": "android_app",+ "package_name": "com.streamvault.app.debug",+ "sha256_cert_fingerprints": [+ "79:64:0D:DA:63:77:00:C3:27:68:C7:B6:60:E1:8A:BF:99:13:66:2C:7B:92:D6:33:ED:87:8B:91:B4:D1:AC:DF"+ ]+ }+ }+]diff --git a/docs/trakt-pages/index.html b/docs/trakt-pages/index.htmlnew file mode 100644index 00000000..221184a2--- /dev/null+++ b/docs/trakt-pages/index.html@@ -0,0 +1,25 @@+<!doctype html>+<html lang="en">+<head>+ <meta charset="utf-8">+ <meta name="viewport" content="width=device-width, initial-scale=1">+ <meta name="referrer" content="no-referrer">+ <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'">+ <title>StreamVault</title>+ <style>+ :root { color-scheme: dark; font-family: system-ui, sans-serif; }+ body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: #10131a; color: #f0f3fa; }+ main { max-width: 32rem; margin: 1.5rem; padding: 2rem; border: 1px solid #303a50; border-radius: 1rem; background: #192030; }+ p { line-height: 1.65; color: #c4ccdc; }+ a { color: #9ebfff; }+ </style>+</head>+<body>+ <main>+ <h1>StreamVault</h1>+ <p>An open-source media player for your own sources.</p>+ <p>This site supports StreamVault account connections.</p>+ <a href="https://github.com/Davidona/StreamVault-IPTV" rel="noreferrer">View the project on GitHub</a>+ </main>+</body>+</html>diff --git a/docs/trakt-pages/oauth/trakt/callback/callback.js b/docs/trakt-pages/oauth/trakt/callback/callback.jsnew file mode 100644index 00000000..8034d28d--- /dev/null+++ b/docs/trakt-pages/oauth/trakt/callback/callback.js@@ -0,0 +1,3 @@+// Keep OAuth query values out of the displayed URL and browser history.+// No code/state values are read, rendered, forwarded, or stored by this page.+window.history.replaceState(null, "", window.location.pathname);diff --git a/docs/trakt-pages/oauth/trakt/callback/index.html b/docs/trakt-pages/oauth/trakt/callback/index.htmlnew file mode 100644index 00000000..72ee616b--- /dev/null+++ b/docs/trakt-pages/oauth/trakt/callback/index.html@@ -0,0 +1,31 @@+<!doctype html>+<html lang="en">+<head>+ <meta charset="utf-8">+ <meta name="viewport" content="width=device-width, initial-scale=1">+ <meta name="referrer" content="no-referrer">+ <meta name="robots" content="noindex, nofollow">+ <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'self'; base-uri 'none'; form-action 'none'">+ <title>Return to StreamVault</title>+ <script src="./callback.js"></script>+ <style>+ :root { color-scheme: dark; font-family: system-ui, sans-serif; }+ body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: #10131a; color: #f0f3fa; }+ main { max-width: 32rem; margin: 1.5rem; padding: 2rem; border: 1px solid #303a50; border-radius: 1rem; background: #192030; }+ .brand { color: #9ebfff; font-weight: 650; letter-spacing: .06em; }+ h1 { font-size: 1.75rem; line-height: 1.2; }+ p { line-height: 1.65; color: #c4ccdc; }+ a { color: #9ebfff; }+ </style>+</head>+<body>+ <main>+ <div class="brand">STREAMVAULT</div>+ <h1>Return to StreamVault</h1>+ <p>StreamVault should open automatically to finish connecting your Trakt account.</p>+ <p>If this page opened instead, enable supported links for StreamVault in Android settings. Then return to StreamVault, cancel the pending sign-in, and connect again.</p>+ <p>This page does not finish sign-in or store your Trakt account credentials.</p>+ <a href="https://github.com/Davidona/StreamVault-IPTV" rel="noreferrer">StreamVault project</a>+ </main>+</body>+</html>diff --git a/domain/src/main/java/com/streamvault/domain/model/AppHomeDashboardShelf.kt b/domain/src/main/java/com/streamvault/domain/model/AppHomeDashboardShelf.ktindex e37034eb..5436b202 100644--- a/domain/src/main/java/com/streamvault/domain/model/AppHomeDashboardShelf.kt+++ b/domain/src/main/java/com/streamvault/domain/model/AppHomeDashboardShelf.kt@@ -13,6 +13,8 @@ enum class AppHomeDashboardShelf(RECENT_SERIES("recent_series", defaultEnabled = true),FAVORITE_MOVIES("favorite_movies", defaultEnabled = false),FAVORITE_SERIES("favorite_series", defaultEnabled = false),+ TRAKT_WATCHLIST_MOVIES("trakt_watchlist_movies", defaultEnabled = false),+ TRAKT_WATCHLIST_SERIES("trakt_watchlist_series", defaultEnabled = false),CONTINUE_WATCHING_MOVIES("continue_watching_movies", defaultEnabled = false),CONTINUE_WATCHING_SERIES("continue_watching_series", defaultEnabled = false),TOP_RATED_MOVIES("top_rated_movies", defaultEnabled = false),@@ -29,6 +31,8 @@ enum class AppHomeDashboardShelf(RECENT_SERIES,FAVORITE_MOVIES,FAVORITE_SERIES,+ TRAKT_WATCHLIST_MOVIES,+ TRAKT_WATCHLIST_SERIES,CONTINUE_WATCHING_MOVIES,CONTINUE_WATCHING_SERIES,TOP_RATED_MOVIES,diff --git a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.ktindex 1a01ba33..d8e72ab9 100644--- a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt+++ b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt@@ -15,6 +15,8 @@ import kotlinx.coroutines.flow.flowOfinterface MovieRepository {fun getMovies(providerId: Long): Flow<List<Movie>>+ /** Loads only active-provider rows with the requested Trakt/TMDB identities. */+ suspend fun getMoviesByTmdbIds(providerId: Long, tmdbIds: List<Long>): List<Movie> = emptyList()fun getMoviesByCategory(providerId: Long, categoryId: Long): Flow<List<Movie>>fun getMoviesByCategoryPage(providerId: Long, categoryId: Long, limit: Int, offset: Int): Flow<List<Movie>>fun getMoviesByCategoryPreview(providerId: Long, categoryId: Long, limit: Int): Flow<List<Movie>>diff --git a/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.ktindex 57fc00a8..1cb3882e 100644--- a/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.kt+++ b/domain/src/main/java/com/streamvault/domain/repository/PlaybackHistoryRepository.kt@@ -4,9 +4,18 @@ import com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.PlaybackHistoryimport com.streamvault.domain.model.Resultimport kotlinx.coroutines.flow.Flow+import kotlinx.coroutines.flow.firstinterface PlaybackHistoryRepository {+ suspend fun isIncognitoModeEnabled(): Boolean = falsefun getRecentlyWatched(limit: Int = 100): Flow<List<PlaybackHistory>>+ suspend fun getRecentlyWatchedPage(offset: Int, limit: Int): List<PlaybackHistory> {+ require(offset >= 0)+ require(limit > 0)+ val endExclusive = offset.toLong() + limit+ require(endExclusive <= Int.MAX_VALUE)+ return getRecentlyWatched(endExclusive.toInt()).first().drop(offset).take(limit)+ }fun getRecentlyWatchedByProvider(providerId: Long, limit: Int = 100): Flow<List<PlaybackHistory>>fun getRecentlyWatchedByProviders(providerIds: Set<Long>, limit: Int = 100): Flow<List<PlaybackHistory>>fun getUnwatchedCount(providerId: Long, seriesId: Long): Flow<Int>@@ -20,6 +29,10 @@ interface PlaybackHistoryRepository {): PlaybackHistory?suspend fun markAsWatched(history: PlaybackHistory): Result<Unit>+ suspend fun importTraktHistory(history: PlaybackHistory,+ identity: com.streamvault.domain.trakt.TraktMediaIdentity,+ match: com.streamvault.domain.trakt.TraktHistoryMatch): Result<Boolean> =+ Result.error("History import is unavailable")suspend fun recordPlayback(history: PlaybackHistory): Result<Unit>suspend fun updateResumePosition(history: PlaybackHistory): Result<Unit>suspend fun flushPendingProgress(): Result<Unit>diff --git a/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.ktindex e1a8d2ef..fe9b0b99 100644--- a/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt+++ b/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt@@ -15,6 +15,8 @@ import kotlinx.coroutines.flow.flowOfinterface SeriesRepository {fun getSeries(providerId: Long): Flow<List<Series>>+ /** Loads only active-provider rows with the requested Trakt/TMDB identities. */+ suspend fun getSeriesByTmdbIds(providerId: Long, tmdbIds: List<Long>): List<Series> = emptyList()fun getSeriesByCategory(providerId: Long, categoryId: Long): Flow<List<Series>>fun getSeriesByCategoryPage(providerId: Long, categoryId: Long, limit: Int, offset: Int): Flow<List<Series>>fun getSeriesByCategoryPreview(providerId: Long, categoryId: Long, limit: Int): Flow<List<Series>>diff --git a/domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.kt b/domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.ktindex 9d838ebf..d1c1f070 100644--- a/domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.kt+++ b/domain/src/main/java/com/streamvault/domain/settings/SettingsPreferences.kt@@ -410,6 +410,22 @@ interface SettingsPreferences {suspend fun setVodPortalSearch(enabled: Boolean)+ val showTraktTrendingMovies: Flow<Boolean>++ suspend fun setShowTraktTrendingMovies(enabled: Boolean)++ val showTraktPopularMovies: Flow<Boolean>++ suspend fun setShowTraktPopularMovies(enabled: Boolean)++ val showTraktTrendingSeries: Flow<Boolean>++ suspend fun setShowTraktTrendingSeries(enabled: Boolean)++ val showTraktPopularSeries: Flow<Boolean>++ suspend fun setShowTraktPopularSeries(enabled: Boolean)+val vodCategoryLoadMode: Flow<com.streamvault.domain.model.VodCategoryLoadMode>suspend fun setVodCategoryLoadMode(mode: com.streamvault.domain.model.VodCategoryLoadMode)diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktAccount.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktAccount.ktnew file mode 100644index 00000000..6cd531a8--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktAccount.kt@@ -0,0 +1,36 @@+package com.streamvault.domain.trakt++import kotlinx.coroutines.flow.StateFlow++data class TraktAccountState(+ val configured: Boolean = false,+ val connected: Boolean = false,+ val username: String? = null,+ val connecting: Boolean = false,+ val message: TraktMessage? = null,+ val profile: TraktUserProfile? = null,+)++data class TraktUserProfile(+ val username: String,+ val name: String? = null,+ val location: String? = null,+ val about: String? = null,+ val gender: String? = null,+ val age: Int? = null,+ val joinedAt: String? = null,+ val vip: Boolean = false,+)++enum class TraktMessage { CONFIGURATION_REQUIRED, SIGN_IN_FAILED, RECONNECT_REQUIRED, NETWORK_ERROR, RATE_LIMITED }++/** Account operations expose no credentials to presentation code. */+interface TraktAccount {+ val state: StateFlow<TraktAccountState>+ suspend fun load()+ suspend fun beginSignIn(): String+ suspend fun completeSignIn(callback: String)+ suspend fun cancelSignIn()+ suspend fun disconnect()+ suspend fun refreshProfile()+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktCustomLists.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktCustomLists.ktnew file mode 100644index 00000000..abca46f9--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktCustomLists.kt@@ -0,0 +1,161 @@+package com.streamvault.domain.trakt++import kotlinx.coroutines.flow.StateFlow++enum class TraktCustomListItemType(val apiPath: String, val payloadKey: String, val responseKey: String) {+ MOVIE("movies", "movies", "movie"),+ SHOW("shows", "shows", "show"),+ SEASON("seasons", "seasons", "season"),+ EPISODE("episodes", "episodes", "episode"),+}++data class TraktCustomListItemIdentity(+ val type: TraktCustomListItemType,+ /** TMDB id of the movie/show, or the parent show for season and episode entries. */+ val tmdbId: Long,+ val seasonNumber: Int? = null,+ val episodeNumber: Int? = null,+) {+ init {+ require(tmdbId > 0L)+ when (type) {+ TraktCustomListItemType.MOVIE, TraktCustomListItemType.SHOW ->+ require(seasonNumber == null && episodeNumber == null)+ TraktCustomListItemType.SEASON ->+ require(seasonNumber != null && seasonNumber >= 0 && episodeNumber == null)+ TraktCustomListItemType.EPISODE ->+ require(seasonNumber != null && seasonNumber >= 0 && episodeNumber != null && episodeNumber > 0)+ }+ }+}++data class TraktCustomList(+ val id: Long,+ val name: String,+ val description: String? = null,+ val privacy: String = "private",+ val itemCount: Int = 0,+) {+ init {+ require(id > 0L)+ require(name.isNotBlank())+ require(itemCount >= 0)+ }+}++data class TraktCustomListItem(+ val identity: TraktCustomListItemIdentity,+ val title: String,+ val year: Int? = null,+ val rank: Int? = null,+ /** Trakt's stable list-entry id, required by the item-reorder endpoint. */+ val listItemId: Long? = null,+) {+ init {+ require(title.isNotBlank())+ require(listItemId == null || listItemId > 0L)+ }+}++data class TraktCustomListItemsPage(+ val items: List<TraktCustomListItem>,+ val page: Int,+ val hasMore: Boolean,+ val skippedItems: Int = 0,+)++enum class TraktCustomListsFailure {+ DISCONNECTED,+ INCOGNITO,+ ACCOUNT_CHANGED,+ READ_LIMIT,+ REQUEST_FAILED,+}++data class TraktCustomListsState(+ val accountUsername: String? = null,+ val connected: Boolean = false,+ val lists: List<TraktCustomList> = emptyList(),+ val listsLoadedAtMs: Long? = null,+ val refreshingLists: Boolean = false,+ val loadingItems: Set<Long> = emptySet(),+ val itemsByList: Map<Long, List<TraktCustomListItem>> = emptyMap(),+ val itemsLoadedAtMs: Map<Long, Long> = emptyMap(),+ val updatingItems: Set<Pair<Long, TraktCustomListItemIdentity>> = emptySet(),+ val failure: TraktCustomListsFailure? = null,+) {+ val listsLoaded: Boolean get() = listsLoadedAtMs != null+ fun list(id: Long): TraktCustomList? = lists.firstOrNull { it.id == id }+ fun itemsLoaded(id: Long): Boolean = id in itemsLoadedAtMs+ fun contains(id: Long, identity: TraktCustomListItemIdentity): Boolean =+ itemsByList[id].orEmpty().any { it.identity == identity }+}++sealed interface TraktCustomListsPageResult {+ data class Success(val lists: List<TraktCustomList>) : TraktCustomListsPageResult+ data object Disconnected : TraktCustomListsPageResult+ data object Failed : TraktCustomListsPageResult+}++sealed interface TraktCustomListItemsPageResult {+ data class Success(val page: TraktCustomListItemsPage) : TraktCustomListItemsPageResult+ data object Disconnected : TraktCustomListItemsPageResult+ data object Failed : TraktCustomListItemsPageResult+}++sealed interface TraktCustomListWriteResult {+ data object Success : TraktCustomListWriteResult+ data object Disconnected : TraktCustomListWriteResult+ data object Failed : TraktCustomListWriteResult+}++sealed interface TraktCustomListRefreshResult {+ data class Success(val listCount: Int) : TraktCustomListRefreshResult+ data class Failure(val reason: TraktCustomListsFailure) : TraktCustomListRefreshResult+}++sealed interface TraktCustomListItemsRefreshResult {+ data class Success(val itemCount: Int, val skipped: Int = 0) : TraktCustomListItemsRefreshResult+ data class Failure(val reason: TraktCustomListsFailure) : TraktCustomListItemsRefreshResult+}++sealed interface TraktCustomListActionResult {+ data object Success : TraktCustomListActionResult+ data class Failure(val reason: TraktCustomListsFailure) : TraktCustomListActionResult+}++/** Explicit, on-demand access to the connected user's personal Trakt lists. */+interface TraktCustomLists {+ val state: StateFlow<TraktCustomListsState>+ suspend fun refreshLists(force: Boolean = false): TraktCustomListRefreshResult+ suspend fun refreshItems(listId: Long, force: Boolean = false): TraktCustomListItemsRefreshResult+ suspend fun createList(name: String, description: String? = null): TraktCustomListActionResult+ suspend fun deleteList(listId: Long): TraktCustomListActionResult+ /** Reorders every list currently loaded for the connected account. */+ suspend fun reorderLists(listIds: List<Long>): TraktCustomListActionResult+ suspend fun reorderItems(listId: Long, items: List<TraktCustomListItem>): TraktCustomListActionResult+ suspend fun setItem(+ listId: Long,+ item: TraktCustomListItem,+ included: Boolean,+ ): TraktCustomListActionResult+}++/** Authenticated transport used by the account service to access personal lists. */+interface TraktCustomListsSource {+ suspend fun lists(): TraktCustomListsPageResult+ suspend fun items(+ listId: Long,+ type: TraktCustomListItemType,+ page: Int,+ ): TraktCustomListItemsPageResult+ suspend fun createList(name: String, description: String?): TraktCustomListWriteResult+ suspend fun deleteList(listId: Long): TraktCustomListWriteResult+ suspend fun reorderLists(listIds: List<Long>): TraktCustomListWriteResult+ suspend fun reorderItems(listId: Long, listItemIds: List<Long>): TraktCustomListWriteResult+ suspend fun setItem(+ listId: Long,+ identity: TraktCustomListItemIdentity,+ included: Boolean,+ ): TraktCustomListWriteResult+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktDiscovery.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktDiscovery.ktnew file mode 100644index 00000000..5ca6a8ac--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktDiscovery.kt@@ -0,0 +1,48 @@+package com.streamvault.domain.trakt++import kotlinx.coroutines.flow.StateFlow++enum class TraktDiscoveryMedia(val apiPath: String) {+ MOVIE("movies"),+ SHOW("shows"),+}++enum class TraktDiscoveryKind(val apiPath: String) {+ TRENDING("trending"),+ POPULAR("popular"),+}++data class TraktDiscoveryCategory(+ val media: TraktDiscoveryMedia,+ val kind: TraktDiscoveryKind,+)++data class TraktDiscoveryPage(+ val tmdbIds: List<Long>,+ val skippedItems: Int = 0,+)++data class TraktDiscoveryState(+ val itemsByCategory: Map<TraktDiscoveryCategory, List<Long>> = emptyMap(),+ val loadedAtByCategory: Map<TraktDiscoveryCategory, Long> = emptyMap(),+ val refreshing: Set<TraktDiscoveryCategory> = emptySet(),+ val failed: Set<TraktDiscoveryCategory> = emptySet(),+) {+ fun items(category: TraktDiscoveryCategory): List<Long> = itemsByCategory[category].orEmpty()+ fun isLoaded(category: TraktDiscoveryCategory): Boolean = category in loadedAtByCategory+}++sealed interface TraktDiscoveryRefreshResult {+ data class Success(val itemCount: Int, val skipped: Int = 0) : TraktDiscoveryRefreshResult+ data object Failure : TraktDiscoveryRefreshResult+}++/** Public Trakt discovery data. It does not require a signed-in account. */+interface TraktDiscovery {+ val state: StateFlow<TraktDiscoveryState>+ suspend fun refresh(category: TraktDiscoveryCategory, force: Boolean = false): TraktDiscoveryRefreshResult+}++interface TraktDiscoverySource {+ suspend fun discover(category: TraktDiscoveryCategory, page: Int): TraktDiscoveryPage+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktFavorites.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktFavorites.ktnew file mode 100644index 00000000..7cdc542e--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktFavorites.kt@@ -0,0 +1,66 @@+package com.streamvault.domain.trakt++/** The movie/show identities accepted by Trakt's personal favorites sync endpoints. */+enum class TraktFavoriteType(val apiPath: String, val payloadKey: String, val responseKey: String) {+ MOVIE("movies", "movies", "movie"),+ SHOW("shows", "shows", "show"),+}++data class TraktFavoriteIdentity(val type: TraktFavoriteType, val tmdbId: Long) {+ init { require(tmdbId > 0) }+}++enum class TraktFavoriteFailure {+ DISCONNECTED,+ INCOGNITO,+ ACCOUNT_CHANGED,+ NO_ACTIVE_PROVIDER,+ READ_LIMIT,+ REQUEST_FAILED,+}++data class TraktFavoritePage(+ val identities: List<TraktFavoriteIdentity>,+ val page: Int,+ val hasMore: Boolean,+ val skippedItems: Int = 0,+)++sealed interface TraktFavoritePageResult {+ data class Success(val page: TraktFavoritePage) : TraktFavoritePageResult+ data object Disconnected : TraktFavoritePageResult+ data object Failed : TraktFavoritePageResult+}++sealed interface TraktFavoriteImportResult {+ data class Success(val imported: Int, val alreadyPresent: Int, val unmatched: Int, val skipped: Int) : TraktFavoriteImportResult+ data class Failure(val reason: TraktFavoriteFailure, val imported: Int = 0) : TraktFavoriteImportResult+}++sealed interface TraktFavoriteActionResult {+ data object Success : TraktFavoriteActionResult+ data class Failure(val reason: TraktFavoriteFailure) : TraktFavoriteActionResult+}++sealed interface TraktFavoriteWriteResult {+ data object Success : TraktFavoriteWriteResult+ data object Disconnected : TraktFavoriteWriteResult+ data object Failed : TraktFavoriteWriteResult+}++/** Explicit write-through for StreamVault's movie/show heart action. */+interface TraktFavorites {+ suspend fun setFavorited(identity: TraktFavoriteIdentity, favorited: Boolean): TraktFavoriteActionResult+}++/** Authenticated transport used by the Trakt account service. */+interface TraktFavoritesSource {+ suspend fun favorites(type: TraktFavoriteType, page: Int): TraktFavoritePageResult =+ TraktFavoritePageResult.Failed+ suspend fun setFavorited(identity: TraktFavoriteIdentity, favorited: Boolean): TraktFavoriteWriteResult+}++/** Explicitly imports existing Trakt hearts into the currently active provider's local Favorites. */+interface TraktFavoriteImporter {+ suspend fun importToLocal(): TraktFavoriteImportResult+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktFeaturePreferences.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktFeaturePreferences.ktnew file mode 100644index 00000000..b6a1fee3--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktFeaturePreferences.kt@@ -0,0 +1,11 @@+package com.streamvault.domain.trakt++import kotlinx.coroutines.flow.Flow++/** User choices that control optional Trakt reads and playback writes. */+interface TraktFeaturePreferences {+ val scrobblingEnabled: Flow<Boolean>+ suspend fun setScrobblingEnabled(enabled: Boolean)+ val historySyncEnabled: Flow<Boolean>+ suspend fun setHistorySyncEnabled(enabled: Boolean)+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktHistory.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktHistory.ktnew file mode 100644index 00000000..5a131fe8--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktHistory.kt@@ -0,0 +1,78 @@+package com.streamvault.domain.trakt++import com.streamvault.domain.model.PlaybackHistory+import com.streamvault.domain.model.PlaybackWatchedStatus+import com.streamvault.domain.model.ContentType++data class TraktHistoryEntry(val historyId: Long, val media: TraktMediaIdentity, val watchedAtMs: Long) {+ init { require(historyId > 0 && watchedAtMs >= 0) }+}+data class TraktHistoryPage(val entries: List<TraktHistoryEntry>, val page: Int,+ val hasMore: Boolean, val skippedEntries: Int = 0)+sealed interface TraktHistoryResult {+ data class Success(val history: TraktHistoryPage) : TraktHistoryResult+ data object Disconnected : TraktHistoryResult+ data class Failure(val message: TraktMessage) : TraktHistoryResult+}+interface TraktHistorySource {+ suspend fun history(page: Int = 1): TraktHistoryResult+ suspend fun upload(accountUsername: String,+ events: List<TraktHistoryUpload>): TraktHistoryUploadResult = TraktHistoryUploadResult.Failed+}++enum class TraktSyncFailure { DISCONNECTED, ACCOUNT_CHANGED, READ_FAILED, READ_LIMIT, IMPORT_FAILED, UPLOAD_FAILED, INCOGNITO }+sealed interface TraktHistorySyncResult {+ data class Success(val imported: Int, val unchanged: Int, val unmatched: Int, val skipped: Int,+ val uploaded: Int = 0, val moreUploads: Boolean = false) : TraktHistorySyncResult+ data class Failure(val reason: TraktSyncFailure, val imported: Int = 0, val uploaded: Int = 0) : TraktHistorySyncResult+}+interface TraktHistorySync {+ suspend fun sync(): TraktHistorySyncResult+}++data class TraktHistoryUpload(val media: TraktMediaIdentity, val watchedAtMs: Long) {+ init { require(watchedAtMs > 0) }+}+sealed interface TraktHistoryUploadResult {+ data class Success(val uploaded: Int, val unmatched: Int = 0) : TraktHistoryUploadResult+ data object Disconnected : TraktHistoryUploadResult+ data object Failed : TraktHistoryUploadResult+}++data class TraktHistoryMatch(val media: TraktMediaIdentity, val watchedAtMs: Long, val playCount: Int)++/** Duplicate pages do not add plays. Conflicting identities for one history ID are discarded. */+class TraktHistoryIndex(entries: List<TraktHistoryEntry>) {+ private val matches = entries.groupBy { it.historyId }.values+ .filter { copies -> copies.map { it.media }.distinct().size == 1 }+ .map { copies -> copies.maxBy { it.watchedAtMs } }+ .groupBy { it.media }+ .mapValues { (media, plays) -> TraktHistoryMatch(media, plays.maxOf { it.watchedAtMs }, plays.size) }++ fun find(media: TraktMediaIdentity): TraktHistoryMatch? = matches[media]++ /** Trakt now normalizes watched_at to minute precision, so compare at that precision. */+ fun contains(media: TraktMediaIdentity, watchedAtMs: Long): Boolean =+ matches[media]?.watchedAtMs?.let { it >= watchedAtMs / 60_000 * 60_000 } == true+}++/** Produces an import candidate only; callers must explicitly choose to apply it. */+object TraktHistoryMergePolicy {+ fun importCandidate(local: PlaybackHistory, identity: TraktMediaIdentity, match: TraktHistoryMatch?): PlaybackHistory? {+ val correctKind = when (identity) {+ is TraktMediaIdentity.MovieId -> local.contentType == ContentType.MOVIE+ is TraktMediaIdentity.EpisodeId -> local.contentType == ContentType.SERIES_EPISODE &&+ local.seasonNumber == identity.season && local.episodeNumber == identity.number+ }+ if (!correctKind || match?.media != identity || local.watchedStatus == PlaybackWatchedStatus.COMPLETED_MANUAL ||+ local.lastWatchedAt > match.watchedAtMs) return null+ val candidate = local.copy(+ // Existing catalog projections use playback position to display completion.+ resumePositionMs = maxOf(local.resumePositionMs, local.totalDurationMs),+ watchedStatus = PlaybackWatchedStatus.COMPLETED_AUTO,+ lastWatchedAt = maxOf(local.lastWatchedAt, match.watchedAtMs),+ watchCount = maxOf(local.watchCount, match.playCount),+ )+ return candidate.takeIf { it != local }+ }+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktMediaIdentity.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktMediaIdentity.ktnew file mode 100644index 00000000..35a012ad--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktMediaIdentity.kt@@ -0,0 +1,34 @@+package com.streamvault.domain.trakt++import com.streamvault.domain.model.Episode+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Series++/** Provider-independent identity; titles, URLs, and provider stream IDs are never identifiers. */+sealed interface TraktMediaIdentity {+ data class MovieId(val tmdbId: Long) : TraktMediaIdentity {+ init { require(tmdbId > 0) }+ }++ /** The TMDB ID belongs to the show, not the episode. Season zero represents specials. */+ data class EpisodeId(val showTmdbId: Long, val season: Int, val number: Int) : TraktMediaIdentity {+ init {+ require(showTmdbId > 0)+ require(season >= 0)+ require(number > 0)+ }+ }+}++/** Missing or inconsistent metadata means no automatic tracking, rather than a title guess. */+object TraktMediaIdentityResolver {+ fun movie(movie: Movie): TraktMediaIdentity.MovieId? =+ movie.tmdbId?.takeIf { it > 0 }?.let(TraktMediaIdentity::MovieId)++ fun episode(series: Series, episode: Episode): TraktMediaIdentity.EpisodeId? {+ val showId = series.tmdbId?.takeIf { it > 0 } ?: return null+ if (series.id <= 0 || episode.seriesId != series.id || episode.providerId != series.providerId ||+ episode.episodeNumber <= 0 || episode.seasonNumber < 0) return null+ return TraktMediaIdentity.EpisodeId(showId, episode.seasonNumber, episode.episodeNumber)+ }+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktRatings.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktRatings.ktnew file mode 100644index 00000000..a9c0565b--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktRatings.kt@@ -0,0 +1,74 @@+package com.streamvault.domain.trakt++enum class TraktRatingType(val apiPath: String, val payloadKey: String, val responseKey: String) {+ MOVIE("movies", "movies", "movie"),+ SHOW("shows", "shows", "show"),+}++data class TraktRatingIdentity(val type: TraktRatingType, val tmdbId: Long) {+ init { require(tmdbId > 0L) }+}++enum class TraktRatingFailure {+ DISCONNECTED,+ INCOGNITO,+ ACCOUNT_CHANGED,+ READ_LIMIT,+ REQUEST_FAILED,+}++data class TraktRatingPage(+ val items: List<Pair<TraktRatingIdentity, Int>>,+ val page: Int,+ val hasMore: Boolean,+ val skippedItems: Int = 0,+)++sealed interface TraktRatingPageResult {+ data class Success(val page: TraktRatingPage) : TraktRatingPageResult+ data object Disconnected : TraktRatingPageResult+ data object Failed : TraktRatingPageResult+}++data class TraktRatingsState(+ val accountUsername: String? = null,+ val connected: Boolean = false,+ val ratings: Map<TraktRatingIdentity, Int> = emptyMap(),+ val loadedTypes: Set<TraktRatingType> = emptySet(),+ val loadedAtMs: Map<TraktRatingType, Long> = emptyMap(),+ val refreshing: Set<TraktRatingType> = emptySet(),+ val updating: Set<TraktRatingIdentity> = emptySet(),+ val failure: TraktRatingFailure? = null,+) {+ fun rating(identity: TraktRatingIdentity): Int? = ratings[identity]+ fun isLoaded(type: TraktRatingType): Boolean = type in loadedTypes+}++sealed interface TraktRatingRefreshResult {+ data class Success(val itemCount: Int, val skipped: Int = 0) : TraktRatingRefreshResult+ data class Failure(val reason: TraktRatingFailure) : TraktRatingRefreshResult+}++sealed interface TraktRatingActionResult {+ data object Success : TraktRatingActionResult+ data class Failure(val reason: TraktRatingFailure) : TraktRatingActionResult+}++sealed interface TraktRatingWriteResult {+ data object Success : TraktRatingWriteResult+ data object Disconnected : TraktRatingWriteResult+ data object Failed : TraktRatingWriteResult+}++/** Explicit user ratings for exact TMDB-matched movies and shows. */+interface TraktRatings {+ val state: kotlinx.coroutines.flow.StateFlow<TraktRatingsState>+ suspend fun refresh(type: TraktRatingType, force: Boolean = false): TraktRatingRefreshResult+ suspend fun setRating(identity: TraktRatingIdentity, rating: Int): TraktRatingActionResult+}++/** Authenticated transport exposed by the Trakt account service. */+interface TraktRatingsSource {+ suspend fun ratings(type: TraktRatingType, page: Int): TraktRatingPageResult+ suspend fun setRating(identity: TraktRatingIdentity, rating: Int): TraktRatingWriteResult+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktScrobble.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktScrobble.ktnew file mode 100644index 00000000..bcd6d10d--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktScrobble.kt@@ -0,0 +1,58 @@+package com.streamvault.domain.trakt++enum class TraktScrobbleAction { START, PAUSE, STOP }+data class TraktScrobbleEvent(+ val media: TraktMediaIdentity,+ val action: TraktScrobbleAction,+ val progress: Double,+) {+ init { require(progress.isFinite() && progress in 0.0..100.0) }+}+enum class TraktScrobbleOutcome { SENT, DISCONNECTED, UNMATCHED, DUPLICATE, FAILED }+interface TraktScrobbler {+ suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome+}++enum class TraktPlaybackPhase { PLAYING, PAUSED, BUFFERING, STOPPED, ENDED }++/** Session numbers must increase when media changes, including replaying the same title. */+class TraktScrobblePlanner {+ private var session = Long.MIN_VALUE+ private var media: TraktMediaIdentity? = null+ private var lastAction: TraktScrobbleAction? = null+ private var progress = 0.0+ private var closed = false++ fun observe(sessionId: Long, identity: TraktMediaIdentity?, phase: TraktPlaybackPhase,+ positionMs: Long, durationMs: Long): List<TraktScrobbleEvent> {+ if (sessionId < session) return emptyList()+ val events = mutableListOf<TraktScrobbleEvent>()+ if (sessionId > session) {+ if (!closed && lastAction != null) media?.let {+ events += TraktScrobbleEvent(it, TraktScrobbleAction.STOP, progress)+ }+ session = sessionId+ media = identity+ lastAction = null+ progress = 0.0+ closed = false+ }+ if (media == null && lastAction == null && identity != null) media = identity+ if (closed || identity == null || media != identity) return events+ if (durationMs > 0) progress = (positionMs.coerceAtLeast(0).toDouble() / durationMs * 100).coerceIn(0.0, 100.0)+ val action = when (phase) {+ TraktPlaybackPhase.PLAYING -> if (durationMs > 0) TraktScrobbleAction.START else null+ TraktPlaybackPhase.PAUSED -> if (lastAction != null) TraktScrobbleAction.PAUSE else null+ TraktPlaybackPhase.BUFFERING -> null+ TraktPlaybackPhase.STOPPED, TraktPlaybackPhase.ENDED -> {+ closed = true+ if (lastAction != null) TraktScrobbleAction.STOP else null+ }+ }+ if (action != null && action != lastAction) {+ events += TraktScrobbleEvent(identity, action, progress)+ lastAction = action+ }+ return events+ }+}diff --git a/domain/src/main/java/com/streamvault/domain/trakt/TraktWatchlist.kt b/domain/src/main/java/com/streamvault/domain/trakt/TraktWatchlist.ktnew file mode 100644index 00000000..e33b258e--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/trakt/TraktWatchlist.kt@@ -0,0 +1,75 @@+package com.streamvault.domain.trakt++import kotlinx.coroutines.flow.StateFlow++enum class TraktWatchlistType(val apiPath: String, val payloadKey: String) {+ MOVIE("movies", "movies"),+ SHOW("shows", "shows"),+}++data class TraktWatchlistIdentity(val type: TraktWatchlistType, val tmdbId: Long) {+ init { require(tmdbId > 0) }+}++data class TraktWatchlistPage(+ val items: List<TraktWatchlistIdentity>,+ val page: Int,+ val hasMore: Boolean,+ val skippedItems: Int = 0,+)++enum class TraktWatchlistFailure {+ DISCONNECTED,+ INCOGNITO,+ ACCOUNT_CHANGED,+ READ_LIMIT,+ REQUEST_FAILED,+}++sealed interface TraktWatchlistPageResult {+ data class Success(val page: TraktWatchlistPage) : TraktWatchlistPageResult+ data object Disconnected : TraktWatchlistPageResult+ data object Failed : TraktWatchlistPageResult+}++sealed interface TraktWatchlistWriteResult {+ data object Success : TraktWatchlistWriteResult+ data object Disconnected : TraktWatchlistWriteResult+ data object Failed : TraktWatchlistWriteResult+}++data class TraktWatchlistState(+ val accountUsername: String? = null,+ val connected: Boolean = false,+ val items: Set<TraktWatchlistIdentity> = emptySet(),+ val loadedAtMs: Long? = null,+ val isRefreshing: Boolean = false,+ val updating: Set<TraktWatchlistIdentity> = emptySet(),+ val failure: TraktWatchlistFailure? = null,+) {+ val loaded: Boolean get() = loadedAtMs != null+ fun contains(identity: TraktWatchlistIdentity): Boolean = identity in items+}++sealed interface TraktWatchlistRefreshResult {+ data class Success(val itemCount: Int, val skipped: Int = 0) : TraktWatchlistRefreshResult+ data class Failure(val reason: TraktWatchlistFailure) : TraktWatchlistRefreshResult+}++sealed interface TraktWatchlistActionResult {+ data object Success : TraktWatchlistActionResult+ data class Failure(val reason: TraktWatchlistFailure) : TraktWatchlistActionResult+}++/** Trakt watchlist operations are explicit and remain scoped to the signed-in account. */+interface TraktWatchlist {+ val state: StateFlow<TraktWatchlistState>+ suspend fun refresh(force: Boolean = false): TraktWatchlistRefreshResult+ suspend fun setWatchlisted(identity: TraktWatchlistIdentity, watchlisted: Boolean): TraktWatchlistActionResult+}++/** Authenticated transport exposed by the account service to the watchlist repository. */+interface TraktWatchlistSource {+ suspend fun watchlist(type: TraktWatchlistType, page: Int): TraktWatchlistPageResult+ suspend fun setWatchlisted(identity: TraktWatchlistIdentity, watchlisted: Boolean): TraktWatchlistWriteResult+}diff --git a/domain/src/test/java/com/streamvault/domain/trakt/TraktHistoryIndexTest.kt b/domain/src/test/java/com/streamvault/domain/trakt/TraktHistoryIndexTest.ktnew file mode 100644index 00000000..1b5cf1d1--- /dev/null+++ b/domain/src/test/java/com/streamvault/domain/trakt/TraktHistoryIndexTest.kt@@ -0,0 +1,16 @@+package com.streamvault.domain.trakt++import org.junit.Assert.*+import org.junit.Test++class TraktHistoryIndexTest {+ @Test fun contains_compares_local_completion_at_trakt_minute_precision() {+ val movie = TraktMediaIdentity.MovieId(603)+ val index = TraktHistoryIndex(listOf(TraktHistoryEntry(1, movie, 120_000)))++ assertTrue(index.contains(movie, 120_001))+ assertTrue(index.contains(movie, 179_999))+ assertFalse(index.contains(movie, 180_000))+ assertFalse(index.contains(TraktMediaIdentity.MovieId(604), 120_001))+ }+}diff --git a/domain/src/test/java/com/streamvault/domain/trakt/TraktHistoryTest.kt b/domain/src/test/java/com/streamvault/domain/trakt/TraktHistoryTest.ktnew file mode 100644index 00000000..1abf23f7--- /dev/null+++ b/domain/src/test/java/com/streamvault/domain/trakt/TraktHistoryTest.kt@@ -0,0 +1,56 @@+package com.streamvault.domain.trakt++import com.streamvault.domain.model.*+import org.junit.Assert.*+import org.junit.Test++class TraktHistoryTest {+ private val movie = TraktMediaIdentity.MovieId(603)+ private val episode = TraktMediaIdentity.EpisodeId(1396, 2, 3)+ private val local = PlaybackHistory(contentId = 42, contentType = ContentType.MOVIE,+ providerId = 7, title = "Movie", streamUrl = "", resumePositionMs = 50,+ totalDurationMs = 100, lastWatchedAt = 1000)+ private val match = TraktHistoryMatch(movie, 2000, 2)++ @Test fun duplicatePagesCountEachHistoryIdOnceAndKeepLatestWatch() {+ val index = TraktHistoryIndex(listOf(TraktHistoryEntry(1, movie, 1000),+ TraktHistoryEntry(1, movie, 1000), TraktHistoryEntry(2, movie, 2000),+ TraktHistoryEntry(3, episode, 3000)))+ assertEquals(match, index.find(movie))+ assertEquals(TraktHistoryMatch(episode, 3000, 1), index.find(episode))+ }++ @Test fun conflictingHistoryIdDoesNotMatchEitherMedia() {+ val index = TraktHistoryIndex(listOf(TraktHistoryEntry(1, movie, 1000), TraktHistoryEntry(1, episode, 2000)))+ assertNull(index.find(movie))+ assertNull(index.find(episode))+ }++ @Test fun importCompletesKnownDurationPreservesLocalCountAndIsIdempotent() {+ val original = local.copy(watchCount = 4)+ val imported = requireNotNull(TraktHistoryMergePolicy.importCandidate(original, movie, match))+ assertEquals(PlaybackWatchedStatus.COMPLETED_AUTO, imported.watchedStatus)+ assertEquals(4, imported.watchCount)+ assertEquals(2000, imported.lastWatchedAt)+ assertEquals(original.totalDurationMs, imported.resumePositionMs)+ assertNull(TraktHistoryMergePolicy.importCandidate(imported, movie, match))+ }++ @Test fun newerLocalRewatchAndManualCompletionArePreserved() {+ assertNull(TraktHistoryMergePolicy.importCandidate(local.copy(lastWatchedAt = 3000), movie, match))+ assertNull(TraktHistoryMergePolicy.importCandidate(local.copy(watchedStatus = PlaybackWatchedStatus.COMPLETED_MANUAL), movie, match))+ }++ @Test fun absenceMismatchedIdentityAndLiveContentNeverProduceImport() {+ assertNull(TraktHistoryMergePolicy.importCandidate(local, movie, null))+ assertNull(TraktHistoryMergePolicy.importCandidate(local, movie, match.copy(media = episode)))+ assertNull(TraktHistoryMergePolicy.importCandidate(local.copy(contentType = ContentType.LIVE), movie, match))+ }++ @Test fun episodeNumbersMustMatchForImport() {+ val history = local.copy(contentType = ContentType.SERIES_EPISODE, seasonNumber = 2, episodeNumber = 3)+ val episodeMatch = match.copy(media = episode)+ assertNotNull(TraktHistoryMergePolicy.importCandidate(history, episode, episodeMatch))+ assertNull(TraktHistoryMergePolicy.importCandidate(history.copy(episodeNumber = 4), episode, episodeMatch))+ }+}diff --git a/domain/src/test/java/com/streamvault/domain/trakt/TraktMediaIdentityResolverTest.kt b/domain/src/test/java/com/streamvault/domain/trakt/TraktMediaIdentityResolverTest.ktnew file mode 100644index 00000000..ce09cc37--- /dev/null+++ b/domain/src/test/java/com/streamvault/domain/trakt/TraktMediaIdentityResolverTest.kt@@ -0,0 +1,58 @@+package com.streamvault.domain.trakt++import com.streamvault.domain.model.Episode+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Series+import org.junit.Assert.assertEquals+import org.junit.Assert.assertNotEquals+import org.junit.Assert.assertNull+import org.junit.Test++class TraktMediaIdentityResolverTest {+ private val series = Series(id = 42, name = "Show", providerId = 7, tmdbId = 1396)+ private val episode = Episode(id = 99, title = "Episode", seasonNumber = 2,+ episodeNumber = 3, seriesId = 42, providerId = 7)++ @Test fun movieRequiresAttachedPositiveIdRatherThanRecognizableTitle() {+ listOf(null, 0L, -1L).forEach { id ->+ assertNull(TraktMediaIdentityResolver.movie(Movie(id = 100, name = "The Matrix (1999)", tmdbId = id)))+ }+ assertEquals(TraktMediaIdentity.MovieId(603),+ TraktMediaIdentityResolver.movie(Movie(id = 100, name = "Provider label", tmdbId = 603)))+ }++ @Test fun movieIdentityIsIndependentOfProviderAndStreamVariant() {+ val first = Movie(id = 100, name = "A", providerId = 7, tmdbId = 603, streamUrl = "first")+ assertEquals(TraktMediaIdentityResolver.movie(first), TraktMediaIdentityResolver.movie(+ first.copy(id = 200, name = "B", providerId = 8, streamUrl = "second")))+ }++ @Test fun episodeUsesShowIdAndExactNumbersRatherThanLocalEpisodeId() {+ assertEquals(TraktMediaIdentity.EpisodeId(1396, 2, 3),+ TraktMediaIdentityResolver.episode(series, episode))+ assertNotEquals(TraktMediaIdentityResolver.episode(series, episode),+ TraktMediaIdentityResolver.episode(series, episode.copy(episodeNumber = 4)))+ }++ @Test fun wrongSeriesOrProviderCannotMatchEvenWithSameEpisodeNumbers() {+ assertNull(TraktMediaIdentityResolver.episode(series.copy(id = 43), episode))+ assertNull(TraktMediaIdentityResolver.episode(series.copy(providerId = 8), episode))+ assertNull(TraktMediaIdentityResolver.episode(series.copy(id = 0), episode.copy(seriesId = 0)))+ }++ @Test fun missingShowIdOrUnknownEpisodeIsNotEligible() {+ listOf(null, 0L, -1L).forEach { id ->+ assertNull(TraktMediaIdentityResolver.episode(series.copy(tmdbId = id), episode))+ }+ assertNull(TraktMediaIdentityResolver.episode(series, episode.copy(episodeNumber = 0)))+ }++ @Test fun specialsAreEligibleAndIdentitySurvivesProviderMigration() {+ val special = episode.copy(seasonNumber = 0)+ assertEquals(TraktMediaIdentity.EpisodeId(1396, 0, 3),+ TraktMediaIdentityResolver.episode(series, special))+ assertEquals(TraktMediaIdentityResolver.episode(series, special),+ TraktMediaIdentityResolver.episode(series.copy(id = 500, providerId = 9),+ special.copy(id = 600, seriesId = 500, providerId = 9)))+ }+}diff --git a/domain/src/test/java/com/streamvault/domain/trakt/TraktScrobblePlannerTest.kt b/domain/src/test/java/com/streamvault/domain/trakt/TraktScrobblePlannerTest.ktnew file mode 100644index 00000000..b62cc36a--- /dev/null+++ b/domain/src/test/java/com/streamvault/domain/trakt/TraktScrobblePlannerTest.kt@@ -0,0 +1,56 @@+package com.streamvault.domain.trakt++import org.junit.Assert.*+import org.junit.Test++class TraktScrobblePlannerTest {+ private val movie = TraktMediaIdentity.MovieId(603)+ private val planner = TraktScrobblePlanner()+ private fun observe(phase: TraktPlaybackPhase, session: Long = 1, position: Long = 100,+ duration: Long = 1000, identity: TraktMediaIdentity? = movie) =+ planner.observe(session, identity, phase, position, duration)++ @Test fun repeatedPositionTicksAndBufferingDoNotSpamStartsOrPauses() {+ assertEquals(TraktScrobbleAction.START, observe(TraktPlaybackPhase.PLAYING).single().action)+ assertTrue(observe(TraktPlaybackPhase.PLAYING, position = 200).isEmpty())+ assertTrue(observe(TraktPlaybackPhase.BUFFERING).isEmpty())+ assertTrue(observe(TraktPlaybackPhase.PLAYING).isEmpty())+ assertEquals(TraktScrobbleAction.PAUSE, observe(TraktPlaybackPhase.PAUSED).single().action)+ assertTrue(observe(TraktPlaybackPhase.PAUSED).isEmpty())+ assertEquals(TraktScrobbleAction.START, observe(TraktPlaybackPhase.PLAYING).single().action)+ }++ @Test fun completionStopsOnceAndCannotRestartWithoutNewSession() {+ observe(TraktPlaybackPhase.PLAYING)+ assertEquals(100.0, observe(TraktPlaybackPhase.ENDED, position = 1000).single().progress, 0.001)+ assertTrue(observe(TraktPlaybackPhase.ENDED).isEmpty())+ assertTrue(observe(TraktPlaybackPhase.PLAYING).isEmpty())+ assertEquals(TraktScrobbleAction.START, observe(TraktPlaybackPhase.PLAYING, session = 2).single().action)+ }++ @Test fun switchingStopsPreviousIdentityBeforeStartingNextAndRejectsStaleSession() {+ observe(TraktPlaybackPhase.PLAYING, position = 350)+ val next = TraktMediaIdentity.EpisodeId(1396, 2, 3)+ val events = observe(TraktPlaybackPhase.PLAYING, session = 2, position = 20, identity = next)+ assertEquals(listOf(TraktScrobbleAction.STOP, TraktScrobbleAction.START), events.map { it.action })+ assertEquals(movie, events[0].media)+ assertEquals(35.0, events[0].progress, .001)+ assertEquals(next, events[1].media)+ assertTrue(observe(TraktPlaybackPhase.ENDED, session = 1).isEmpty())+ assertTrue(observe(TraktPlaybackPhase.PAUSED, session = 2, identity = movie).isEmpty())+ }++ @Test fun noStartForUnknownDurationOrUnidentifiedMediaButLateMetadataCanStart() {+ assertTrue(observe(TraktPlaybackPhase.PLAYING, duration = 0, identity = null).isEmpty())+ assertTrue(observe(TraktPlaybackPhase.PLAYING, duration = 0).isEmpty())+ assertEquals(0.0, observe(TraktPlaybackPhase.PLAYING, position = -10).single().progress, .001)+ }++ @Test fun switchingToLiveOrUnknownContentOnlyStopsOldItem() {+ assertTrue(observe(TraktPlaybackPhase.PAUSED).isEmpty())+ observe(TraktPlaybackPhase.PLAYING)+ assertEquals(TraktScrobbleAction.STOP,+ observe(TraktPlaybackPhase.PLAYING, session = 2, identity = null).single().action)+ assertTrue(observe(TraktPlaybackPhase.PLAYING, session = 2, identity = null).isEmpty())+ }+}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/api/CatalogPlatformPorts.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/api/CatalogPlatformPorts.ktindex 68d6392f..51c013a0 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/api/CatalogPlatformPorts.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/api/CatalogPlatformPorts.kt@@ -43,6 +43,10 @@ enum class CatalogMessage {DownloadStarted,DownloadFailed,DownloadUrlUnavailable,+ TraktWatchlistFailed,+ TraktFavoriteSyncFailed,+ TraktRatingSaved,+ TraktRatingFailed,}sealed interface CatalogCastStartResult {diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/CatalogMessageText.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/CatalogMessageText.ktindex f15766c5..cb18d315 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/CatalogMessageText.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/CatalogMessageText.kt@@ -14,4 +14,8 @@ internal fun Context.catalogMessageText(message: CatalogMessage): String = whenCatalogMessage.DownloadStarted -> getString(R.string.download_started)CatalogMessage.DownloadFailed -> getString(R.string.download_failed, "")CatalogMessage.DownloadUrlUnavailable -> getString(R.string.download_error_no_url)+ CatalogMessage.TraktWatchlistFailed -> getString(R.string.trakt_watchlist_failed)+ CatalogMessage.TraktFavoriteSyncFailed -> getString(R.string.trakt_favorite_sync_failed)+ CatalogMessage.TraktRatingSaved -> getString(R.string.trakt_rating_saved)+ CatalogMessage.TraktRatingFailed -> getString(R.string.trakt_rating_failed)}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktCustomListAction.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktCustomListAction.ktnew file mode 100644index 00000000..37150210--- /dev/null+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktCustomListAction.kt@@ -0,0 +1,423 @@+package com.streamvault.feature.catalog.presentation.components++import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.layout.widthIn+import androidx.compose.foundation.rememberScrollState+import androidx.compose.foundation.verticalScroll+import androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.runtime.Composable+import androidx.compose.runtime.collectAsState+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue+import androidx.compose.ui.Modifier+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.unit.dp+import androidx.compose.ui.window.Dialog+import androidx.compose.ui.window.DialogProperties+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel+import androidx.lifecycle.ViewModel+import androidx.lifecycle.viewModelScope+import androidx.tv.material3.ButtonDefaults+import androidx.tv.material3.Surface+import androidx.tv.material3.SurfaceDefaults+import androidx.tv.material3.Text+import com.streamvault.core.ui.design.AppColors+import com.streamvault.core.ui.components.TvOutlinedTextField+import com.streamvault.core.ui.interaction.TvButton+import com.streamvault.domain.trakt.TraktCustomListActionResult+import com.streamvault.domain.trakt.TraktCustomListItem+import com.streamvault.domain.trakt.TraktCustomListItemType+import com.streamvault.domain.trakt.TraktCustomListItemsRefreshResult+import com.streamvault.domain.trakt.TraktCustomListRefreshResult+import com.streamvault.domain.trakt.TraktCustomLists+import com.streamvault.domain.trakt.TraktCustomListsFailure+import com.streamvault.feature.catalog.R+import dagger.hilt.android.lifecycle.HiltViewModel+import javax.inject.Inject+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.launch++@HiltViewModel+class TraktCustomListActionViewModel @Inject constructor(+ private val customLists: TraktCustomLists,+) : ViewModel() {+ val state = customLists.state+ private val mutableOperation = MutableStateFlow(false)+ val operation = mutableOperation.asStateFlow()+ private val mutableFailure = MutableStateFlow<TraktCustomListsFailure?>(null)+ val failure = mutableFailure.asStateFlow()++ fun refreshLists() = runOperation {+ when (val result = customLists.refreshLists()) {+ is TraktCustomListRefreshResult.Success -> Unit+ is TraktCustomListRefreshResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun refreshItems(listId: Long) = runOperation {+ when (val result = customLists.refreshItems(listId)) {+ is TraktCustomListItemsRefreshResult.Success -> Unit+ is TraktCustomListItemsRefreshResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun setItem(listId: Long, item: TraktCustomListItem, included: Boolean) = runOperation {+ when (val result = customLists.setItem(listId, item, included)) {+ TraktCustomListActionResult.Success -> mutableFailure.value = null+ is TraktCustomListActionResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun createList(name: String, description: String, onCreated: () -> Unit) = runOperation {+ when (val result = customLists.createList(name, description.takeIf(String::isNotBlank))) {+ TraktCustomListActionResult.Success -> {+ onCreated()+ when (val refresh = customLists.refreshLists(force = true)) {+ is TraktCustomListRefreshResult.Success -> Unit+ is TraktCustomListRefreshResult.Failure -> mutableFailure.value = refresh.reason+ }+ }+ is TraktCustomListActionResult.Failure -> mutableFailure.value = result.reason+ }+ }++ private fun runOperation(action: suspend () -> Unit) {+ if (mutableOperation.value) return+ viewModelScope.launch {+ mutableOperation.value = true+ mutableFailure.value = null+ try { action() } finally { mutableOperation.value = false }+ }+ }+}++@Composable+internal fun TraktCustomListActionButton(+ item: TraktCustomListItem?,+ additionalItems: List<TraktCustomListItem> = emptyList(),+) {+ if (item == null) return+ val viewModel: TraktCustomListActionViewModel = hiltViewModel()+ val state by viewModel.state.collectAsState()+ val operation by viewModel.operation.collectAsState()+ val failure by viewModel.failure.collectAsState()+ var dialogOpen by remember(item.identity) { mutableStateOf(false) }+ var selectedListId by remember(item.identity) { mutableStateOf<Long?>(null) }+ var selectedItem by remember(item.identity) {+ mutableStateOf(if (additionalItems.isEmpty()) item else null)+ }+ var choosingItem by remember(item.identity) { mutableStateOf(additionalItems.isNotEmpty()) }+ var selectedItemType by remember(item.identity) { mutableStateOf<TraktCustomListItemType?>(null) }+ var creatingList by remember(item.identity) { mutableStateOf(false) }+ var listName by remember(item.identity) { mutableStateOf("") }+ var listDescription by remember(item.identity) { mutableStateOf("") }++ TvButton(+ onClick = {+ dialogOpen = true+ selectedListId = null+ selectedItem = if (additionalItems.isEmpty()) item else null+ choosingItem = additionalItems.isNotEmpty()+ selectedItemType = null+ creatingList = false+ listName = ""+ listDescription = ""+ viewModel.refreshLists()+ },+ enabled = !operation,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ ),+ ) { Text(stringResource(R.string.trakt_custom_lists_action)) }++ if (!dialogOpen) return+ Dialog(+ onDismissRequest = { if (!operation) dialogOpen = false },+ properties = DialogProperties(usePlatformDefaultWidth = false),+ ) {+ Surface(+ shape = RoundedCornerShape(24.dp),+ colors = SurfaceDefaults.colors(containerColor = AppColors.SurfaceElevated),+ ) {+ Column(+ modifier = Modifier.widthIn(min = 420.dp, max = 680.dp)+ .verticalScroll(rememberScrollState())+ .padding(24.dp),+ verticalArrangement = Arrangement.spacedBy(12.dp),+ ) {+ val selectedList = selectedListId?.let(state::list)+ val targetItem = selectedItem+ Text(+ text = selectedList?.name ?: stringResource(R.string.trakt_custom_lists_title),+ color = AppColors.TextPrimary,+ )+ targetItem?.let {+ Text(+ text = stringResource(R.string.trakt_custom_lists_for_item, it.title),+ color = AppColors.TextSecondary,+ )+ }++ if (state.refreshingLists || selectedListId?.let { it in state.loadingItems } == true || operation) {+ Text(stringResource(R.string.trakt_custom_lists_loading), color = AppColors.TextSecondary)+ }+ if (!state.connected && !state.refreshingLists) {+ Text(stringResource(R.string.trakt_custom_lists_connect_first), color = AppColors.TextSecondary)+ } else if (choosingItem) {+ val choices = (listOf(item) + additionalItems).distinctBy { it.identity }+ if (selectedItemType == null) {+ Text(stringResource(R.string.trakt_custom_lists_choose_item), color = AppColors.TextSecondary)+ choices.map { it.identity.type }.distinct().forEach { type ->+ val count = choices.count { it.identity.type == type }+ TvButton(+ onClick = {+ if (count == 1) {+ selectedItem = choices.single { it.identity.type == type }+ choosingItem = false+ } else selectedItemType = type+ },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) {+ val label = when (type) {+ TraktCustomListItemType.MOVIE -> stringResource(R.string.trakt_custom_lists_movies)+ TraktCustomListItemType.SHOW -> stringResource(R.string.trakt_custom_lists_series)+ TraktCustomListItemType.SEASON -> stringResource(R.string.trakt_custom_lists_seasons_count, count)+ TraktCustomListItemType.EPISODE -> stringResource(R.string.trakt_custom_lists_episodes_count, count)+ }+ Text(label)+ }+ }+ } else {+ val choicesOfType = choices.filter { it.identity.type == selectedItemType }+ choicesOfType.forEach { choice ->+ TvButton(+ onClick = {+ selectedItem = choice+ choosingItem = false+ selectedItemType = null+ },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) { Text(choice.title) }+ }+ TvButton(+ onClick = { selectedItemType = null },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) { Text(stringResource(R.string.trakt_custom_lists_back)) }+ }+ } else if (creatingList) {+ TvOutlinedTextField(+ value = listName,+ onValueChange = { listName = it },+ label = {+ Text(+ stringResource(R.string.trakt_custom_lists_name),+ color = AppColors.TextSecondary,+ )+ },+ singleLine = true,+ enabled = !operation,+ modifier = Modifier.fillMaxWidth(),+ colors = { containerFocused -> traktCustomListTextFieldColors(containerFocused) },+ )+ TvOutlinedTextField(+ value = listDescription,+ onValueChange = { listDescription = it },+ label = {+ Text(+ stringResource(R.string.trakt_custom_lists_optional_description),+ color = AppColors.TextSecondary,+ )+ },+ minLines = 2,+ maxLines = 3,+ enabled = !operation,+ modifier = Modifier.fillMaxWidth(),+ colors = { containerFocused -> traktCustomListTextFieldColors(containerFocused) },+ )+ Text(stringResource(R.string.trakt_custom_lists_private_note), color = AppColors.TextSecondary)+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ TvButton(+ onClick = { creatingList = false },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) {+ Text(stringResource(R.string.trakt_custom_lists_back))+ }+ TvButton(+ onClick = {+ viewModel.createList(listName.trim(), listDescription) {+ creatingList = false+ listName = ""+ listDescription = ""+ }+ },+ enabled = !operation && listName.isNotBlank(),+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Brand,+ contentColor = AppColors.OnPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis,+ disabledContentColor = AppColors.TextSecondary,+ ),+ ) {+ Text(stringResource(R.string.trakt_custom_lists_create))+ }+ }+ } else if (selectedItem != null && selectedListId == null) {+ if (state.listsLoaded && state.lists.isEmpty()) {+ Text(stringResource(R.string.trakt_custom_lists_empty), color = AppColors.TextSecondary)+ }+ state.lists.forEach { list ->+ TvButton(+ onClick = {+ selectedListId = list.id+ viewModel.refreshItems(list.id)+ },+ enabled = !operation,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ ),+ ) {+ Text(stringResource(R.string.trakt_custom_list_open, list.name, list.itemCount))+ }+ }+ TvButton(+ onClick = { creatingList = true },+ enabled = !operation,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Brand,+ contentColor = AppColors.OnPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis,+ disabledContentColor = AppColors.TextSecondary,+ ),+ ) {+ Text(stringResource(R.string.trakt_custom_lists_create_new))+ }+ } else if (selectedItem != null && selectedList != null) {+ val activeItem = requireNotNull(selectedItem)+ val itemsLoaded = state.itemsLoaded(selectedList.id)+ val containsTarget = itemsLoaded && state.contains(selectedList.id, activeItem.identity)+ if (itemsLoaded) {+ Text(+ stringResource(+ if (containsTarget) R.string.trakt_custom_list_contains_item+ else R.string.trakt_custom_list_does_not_contain_item,+ activeItem.title,+ ),+ color = AppColors.TextSecondary,+ )+ TvButton(+ onClick = { viewModel.setItem(selectedList.id, activeItem, !containsTarget) },+ enabled = !operation && (selectedList.id to activeItem.identity) !in state.updatingItems,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Brand,+ contentColor = AppColors.OnPrimary,+ ),+ ) {+ Text(stringResource(+ if (containsTarget) R.string.trakt_custom_list_remove_item+ else R.string.trakt_custom_list_add_item,+ ))+ }+ state.itemsByList[selectedList.id].orEmpty().take(200).forEach { listedItem ->+ if (listedItem.identity == activeItem.identity) return@forEach+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ Text(+ text = listOfNotNull(listedItem.title, listedItem.year?.toString())+ .joinToString(" · "),+ color = AppColors.TextPrimary,+ modifier = Modifier.weight(1f),+ )+ TvButton(+ onClick = { viewModel.setItem(selectedList.id, listedItem, false) },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) { Text(stringResource(R.string.trakt_custom_list_remove_item)) }+ }+ }+ if (state.itemsByList[selectedList.id].orEmpty().size > 200) {+ Text(stringResource(R.string.trakt_custom_list_items_truncated), color = AppColors.TextSecondary)+ }+ }+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ TvButton(+ onClick = { selectedListId = null },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) {+ Text(stringResource(R.string.trakt_custom_lists_back))+ }+ if (additionalItems.isNotEmpty()) {+ TvButton(+ onClick = {+ selectedListId = null+ selectedItem = null+ choosingItem = true+ },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) { Text(stringResource(R.string.trakt_custom_lists_change_item)) }+ }+ }+ }++ if (failure != null) {+ Text(+ text = stringResource(+ when (failure) {+ TraktCustomListsFailure.DISCONNECTED -> R.string.trakt_custom_lists_connect_first+ TraktCustomListsFailure.INCOGNITO -> R.string.trakt_custom_lists_incognito+ TraktCustomListsFailure.READ_LIMIT -> R.string.trakt_custom_lists_too_large+ else -> R.string.trakt_custom_lists_failed+ },+ ),+ color = AppColors.Warning,+ )+ }+ TvButton(+ onClick = { dialogOpen = false },+ enabled = !operation,+ colors = traktNeutralButtonColors(),+ ) {+ Text(stringResource(R.string.settings_cancel))+ }+ }+ }+ }+}++@Composable+private fun traktCustomListTextFieldColors(containerFocused: Boolean) = androidx.compose.material3.OutlinedTextFieldDefaults.colors(+ focusedTextColor = AppColors.TextPrimary,+ unfocusedTextColor = AppColors.TextPrimary,+ disabledTextColor = AppColors.TextDisabled,+ cursorColor = AppColors.Brand,+ focusedBorderColor = AppColors.Brand,+ unfocusedBorderColor = if (containerFocused) AppColors.Brand else AppColors.Outline,+ disabledBorderColor = AppColors.Outline.copy(alpha = 0.5f),+ focusedLabelColor = AppColors.Brand,+ unfocusedLabelColor = AppColors.TextSecondary,+ disabledLabelColor = AppColors.TextTertiary,+ focusedContainerColor = AppColors.Surface,+ unfocusedContainerColor = AppColors.Surface,+ disabledContainerColor = AppColors.Surface,+)++@Composable+private fun traktNeutralButtonColors() = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis.copy(alpha = 0.6f),+ disabledContentColor = AppColors.TextSecondary,+)diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktRatingAction.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktRatingAction.ktnew file mode 100644index 00000000..34bf0b85--- /dev/null+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktRatingAction.kt@@ -0,0 +1,117 @@+package com.streamvault.feature.catalog.presentation.components++import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.layout.widthIn+import androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.material.icons.Icons+import androidx.compose.material.icons.filled.Star+import androidx.compose.material.icons.outlined.StarOutline+import androidx.compose.runtime.Composable+import androidx.compose.ui.Modifier+import androidx.compose.ui.graphics.Color+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.unit.dp+import androidx.compose.ui.window.Dialog+import androidx.compose.ui.window.DialogProperties+import androidx.tv.material3.ButtonDefaults+import androidx.tv.material3.Icon+import androidx.tv.material3.Surface+import androidx.tv.material3.SurfaceDefaults+import androidx.tv.material3.Text+import androidx.tv.material3.MaterialTheme+import com.streamvault.core.ui.design.AppColors+import com.streamvault.core.ui.interaction.TvButton+import com.streamvault.core.ui.interaction.TvIconButton+import com.streamvault.feature.catalog.R++@Composable+internal fun TraktRatingActionButton(+ hasIdentity: Boolean,+ connected: Boolean,+ busy: Boolean,+ rating: Int?,+ onClick: () -> Unit,+) {+ if (!hasIdentity) return+ TvIconButton(+ onClick = onClick,+ enabled = connected && !busy,+ colors = ButtonDefaults.colors(+ containerColor = if (rating != null) AppColors.Brand else AppColors.SurfaceEmphasis,+ contentColor = if (rating != null) Color.White else AppColors.TextSecondary,+ ),+ ) {+ Icon(+ imageVector = if (rating != null) Icons.Filled.Star else Icons.Outlined.StarOutline,+ contentDescription = stringResource(+ if (rating == null) R.string.trakt_rating_action else R.string.trakt_rating_current,+ *if (rating == null) emptyArray<Any>() else arrayOf<Any>(rating),+ ),+ )+ }+}++@Composable+internal fun TraktRatingDialog(+ currentRating: Int?,+ busy: Boolean,+ onDismiss: () -> Unit,+ onSelect: (Int) -> Unit,+) {+ Dialog(+ onDismissRequest = { if (!busy) onDismiss() },+ properties = DialogProperties(usePlatformDefaultWidth = false),+ ) {+ Surface(+ shape = RoundedCornerShape(24.dp),+ colors = SurfaceDefaults.colors(containerColor = AppColors.SurfaceElevated),+ ) {+ Column(+ modifier = Modifier.widthIn(min = 320.dp, max = 520.dp).padding(24.dp),+ verticalArrangement = Arrangement.spacedBy(16.dp),+ ) {+ Text(stringResource(R.string.trakt_rating_action), color = AppColors.TextPrimary)+ Text(stringResource(R.string.trakt_rating_dialog_message), color = AppColors.TextSecondary)+ (0..1).forEach { row ->+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {+ (1..5).forEach { column ->+ val value = row * 5 + column+ TvButton(+ onClick = { onSelect(value) },+ enabled = !busy,+ colors = ButtonDefaults.colors(+ containerColor = if (currentRating == value) AppColors.Brand else AppColors.SurfaceEmphasis,+ contentColor = if (currentRating == value) Color.White else AppColors.TextPrimary,+ ),+ ) {+ Text(value.toString())+ }+ }+ }+ }+ currentRating?.let { rating ->+ Text(+ stringResource(R.string.trakt_rating_current, rating),+ color = AppColors.TextSecondary,+ )+ }+ TvButton(onClick = onDismiss, enabled = !busy) {+ Text(stringResource(R.string.settings_cancel))+ }+ }+ }+ }+}++@Composable+internal fun TraktRatingSummary(rating: Int?) {+ if (rating == null) return+ Text(+ text = stringResource(R.string.trakt_rating_current, rating),+ style = MaterialTheme.typography.bodyMedium,+ color = AppColors.Brand+ )+}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktWatchlistActionButton.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktWatchlistActionButton.ktnew file mode 100644index 00000000..67de3c00--- /dev/null+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/components/TraktWatchlistActionButton.kt@@ -0,0 +1,43 @@+package com.streamvault.feature.catalog.presentation.components++import androidx.compose.material.icons.Icons+import androidx.compose.material.icons.filled.Bookmark+import androidx.compose.material.icons.outlined.BookmarkBorder+import androidx.compose.runtime.Composable+import androidx.compose.ui.res.stringResource+import androidx.tv.material3.ButtonDefaults+import androidx.tv.material3.Icon+import com.streamvault.core.ui.design.AppColors+import com.streamvault.core.ui.interaction.TvIconButton+import com.streamvault.feature.catalog.R++@Composable+internal fun TraktWatchlistActionButton(+ hasIdentity: Boolean,+ connected: Boolean,+ loaded: Boolean,+ watchlisted: Boolean,+ busy: Boolean,+ onClick: () -> Unit,+) {+ if (!hasIdentity) return+ val actionLabel = when {+ !connected -> stringResource(R.string.trakt_watchlist_connect)+ !loaded -> stringResource(R.string.trakt_watchlist_load)+ watchlisted -> stringResource(R.string.trakt_watchlist_remove)+ else -> stringResource(R.string.trakt_watchlist_add)+ }+ TvIconButton(+ onClick = onClick,+ enabled = connected && !busy,+ colors = ButtonDefaults.colors(+ containerColor = if (watchlisted) AppColors.Brand else AppColors.SurfaceEmphasis,+ contentColor = if (watchlisted) androidx.compose.ui.graphics.Color.White else AppColors.TextSecondary,+ ),+ ) {+ Icon(+ imageVector = if (watchlisted) Icons.Filled.Bookmark else Icons.Outlined.BookmarkBorder,+ contentDescription = actionLabel,+ )+ }+}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelves.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelves.ktindex d5ff21f8..0c02e33e 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelves.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelves.kt@@ -18,6 +18,8 @@ internal fun DashboardUiState.hasContentFor(shelf: AppHomeDashboardShelf): BooleAppHomeDashboardShelf.RECENT_SERIES -> recentSeries.isNotEmpty()AppHomeDashboardShelf.FAVORITE_MOVIES -> favoriteMovies.isNotEmpty()AppHomeDashboardShelf.FAVORITE_SERIES -> favoriteSeries.isNotEmpty()+ AppHomeDashboardShelf.TRAKT_WATCHLIST_MOVIES -> traktWatchlistMovies.isNotEmpty()+ AppHomeDashboardShelf.TRAKT_WATCHLIST_SERIES -> traktWatchlistSeries.isNotEmpty()AppHomeDashboardShelf.CONTINUE_WATCHING_MOVIES -> continueWatchingMovies.isNotEmpty()AppHomeDashboardShelf.CONTINUE_WATCHING_SERIES -> continueWatchingSeriesItems.isNotEmpty()AppHomeDashboardShelf.TOP_RATED_MOVIES -> topRatedMovies.isNotEmpty()diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardScreen.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardScreen.ktindex a0b620ee..a9ec52f3 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardScreen.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardScreen.kt@@ -290,6 +290,28 @@ fun DashboardScreen()}+ AppHomeDashboardShelf.TRAKT_WATCHLIST_MOVIES -> CategoryRow(+ title = stringResource(R.string.dashboard_trakt_watchlist_movies),+ items = uiState.traktWatchlistMovies,+ keySelector = { it.id },+ onSeeAll = { onDestinationRequested(AppDestination.Movies) }+ ) { movie ->+ MovieCard(movie = movie, onClick = { onMovieClick(movie) })+ }++ AppHomeDashboardShelf.TRAKT_WATCHLIST_SERIES -> CategoryRow(+ title = stringResource(R.string.dashboard_trakt_watchlist_series),+ items = uiState.traktWatchlistSeries,+ keySelector = { it.id },+ onSeeAll = { onDestinationRequested(AppDestination.Series) }+ ) { series ->+ SeriesCard(+ series = series,+ subtitle = series.releaseDate ?: stringResource(R.string.dashboard_updated_series_badge),+ onClick = { onSeriesClick(series) }+ )+ }+AppHomeDashboardShelf.CONTINUE_WATCHING_MOVIES -> ContinueWatchingRow(title = stringResource(R.string.dashboard_continue_watching_movies),items = uiState.continueWatchingMovies,@@ -941,6 +963,8 @@ private fun rememberDashboardSections(uiState.continueWatchingSeriesItems,uiState.favoriteMovies,uiState.favoriteSeries,+ uiState.traktWatchlistMovies,+ uiState.traktWatchlistSeries,uiState.recentMovies,uiState.recentSeries,uiState.topRatedMovies,diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardViewModel.ktindex e2a9efcd..e63c19ad 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardViewModel.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardViewModel.kt@@ -35,6 +35,10 @@ import com.streamvault.domain.usecase.GetContinueWatchingimport com.streamvault.domain.usecase.GetCustomCategoriesimport com.streamvault.domain.manager.RecordingManagerimport com.streamvault.domain.model.RecordingStatus+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistState+import com.streamvault.domain.trakt.TraktWatchlistTypeimport android.content.Contextimport dagger.hilt.android.lifecycle.HiltViewModelimport dagger.hilt.android.qualifiers.ApplicationContext@@ -74,7 +78,9 @@ class DashboardViewModel @Inject constructor(private val getCustomCategories: GetCustomCategories,private val syncManager: ProviderSyncStateSource,private val appUpdatePort: CatalogAppUpdatePort,- private val recordingManager: RecordingManager+ private val recordingManager: RecordingManager,+ private val traktAccount: TraktAccount,+ private val traktWatchlist: TraktWatchlist) : ViewModel() {private companion object {const val FAVORITE_CHANNEL_LIMIT = 12@@ -95,6 +101,15 @@ class DashboardViewModel @Inject constructor(val scheduledChannelIds: StateFlow<Set<Long>> = _scheduledChannelIds.asStateFlow()init {+ viewModelScope.launch {+ traktAccount.state+ .map { state -> state.username.takeIf { state.connected } }+ .distinctUntilChanged()+ .collect { username ->+ if (username != null) traktWatchlist.refresh()+ }+ }+ viewModelScope.launch { traktWatchlist.refresh() }viewModelScope.launch {recordingManager.observeRecordingItems().collect { items ->_recordingChannelIds.value = items@@ -264,6 +279,67 @@ class DashboardViewModel @Inject constructor(.filter { !shouldHideVodFromHome(it, level) }.take(SERIES_SHELF_LIMIT)}+ val activeTraktWatchlistState = combine(traktAccount.state, traktWatchlist.state) { account, watchlist ->+ if (account.connected && account.username == watchlist.accountUsername) {+ watchlist+ } else {+ TraktWatchlistState(accountUsername = account.username, connected = account.connected)+ }+ }.distinctUntilChanged()+ val traktWatchlistMoviesShelf = combine(+ activeTraktWatchlistState,+ preferencesRepository.parentalControlLevel+ ) { watchlist, level -> watchlist to level }+ .flatMapLatest { (watchlist, level) ->+ val movieTmdbIds = watchlist.items.asSequence()+ .filter { it.type == TraktWatchlistType.MOVIE }+ .map { it.tmdbId }+ .toList()+ if (movieTmdbIds.isEmpty()) {+ flowOf(emptyList())+ } else {+ flow {+ val movies = movieRepository.getMoviesByTmdbIds(provider.id, movieTmdbIds)+ emit(+ orderedWatchlistItems(+ watchlistItems = watchlist.items,+ type = TraktWatchlistType.MOVIE,+ catalogItems = movies.filter { !shouldHideVodFromHome(it, level) },+ tmdbIdOf = Movie::tmdbId,+ idOf = Movie::id,+ limit = MOVIE_SHELF_LIMIT+ )+ )+ }+ }+ }+ val traktWatchlistSeriesShelf = combine(+ activeTraktWatchlistState,+ preferencesRepository.parentalControlLevel+ ) { watchlist, level -> watchlist to level }+ .flatMapLatest { (watchlist, level) ->+ val seriesTmdbIds = watchlist.items.asSequence()+ .filter { it.type == TraktWatchlistType.SHOW }+ .map { it.tmdbId }+ .toList()+ if (seriesTmdbIds.isEmpty()) {+ flowOf(emptyList())+ } else {+ flow {+ val series = seriesRepository.getSeriesByTmdbIds(provider.id, seriesTmdbIds)+ emit(+ orderedWatchlistItems(+ watchlistItems = watchlist.items,+ type = TraktWatchlistType.SHOW,+ catalogItems = series.filter { !shouldHideVodFromHome(it, level) },+ tmdbIdOf = Series::tmdbId,+ idOf = Series::id,+ limit = SERIES_SHELF_LIMIT+ )+ )+ }+ }+ }val baseContentShelves = combine(observeFavoriteChannels(liveProviderIds).onStart { emit(emptyList()) },observeRecentChannels(liveProviderIds).onStart { emit(emptyList()) },@@ -309,11 +385,15 @@ class DashboardViewModel @Inject constructor(val contentShelvesWithPinned = combine(contentShelves,pinnedMovieCategoriesShelf,- pinnedSeriesCategoriesShelf- ) { shelves, pinnedMovies, pinnedSeries ->+ pinnedSeriesCategoriesShelf,+ traktWatchlistMoviesShelf.onStart { emit(emptyList()) },+ traktWatchlistSeriesShelf.onStart { emit(emptyList()) }+ ) { shelves, pinnedMovies, pinnedSeries, watchlistMovies, watchlistSeries ->shelves.copy(pinnedMovieCategories = pinnedMovies,- pinnedSeriesCategories = pinnedSeries+ pinnedSeriesCategories = pinnedSeries,+ traktWatchlistMovies = watchlistMovies,+ traktWatchlistSeries = watchlistSeries)}@@ -361,6 +441,8 @@ class DashboardViewModel @Inject constructor(continueWatchingDegraded = snapshot.shelves.continueWatchingDegraded,favoriteMovies = snapshot.shelves.favoriteMovies,favoriteSeries = snapshot.shelves.favoriteSeries,+ traktWatchlistMovies = snapshot.shelves.traktWatchlistMovies,+ traktWatchlistSeries = snapshot.shelves.traktWatchlistSeries,recentMovies = snapshot.shelves.recentMovies,recentSeries = snapshot.shelves.recentSeries,topRatedMovies = snapshot.shelves.topRatedMovies,@@ -868,6 +950,8 @@ private data class DashboardContentShelves(val continueWatchingDegraded: Boolean = false,val favoriteMovies: List<Movie> = emptyList(),val favoriteSeries: List<Series> = emptyList(),+ val traktWatchlistMovies: List<Movie> = emptyList(),+ val traktWatchlistSeries: List<Series> = emptyList(),val recentMovies: List<Movie>,val recentSeries: List<Series>,val topRatedMovies: List<Movie> = emptyList(),@@ -900,6 +984,8 @@ data class DashboardUiState(val continueWatchingDegraded: Boolean = false,val favoriteMovies: List<Movie> = emptyList(),val favoriteSeries: List<Series> = emptyList(),+ val traktWatchlistMovies: List<Movie> = emptyList(),+ val traktWatchlistSeries: List<Series> = emptyList(),val recentMovies: List<Movie> = emptyList(),val recentSeries: List<Series> = emptyList(),val topRatedMovies: List<Movie> = emptyList(),diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/TraktWatchlistShelves.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/TraktWatchlistShelves.ktnew file mode 100644index 00000000..73a112d9--- /dev/null+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/dashboard/TraktWatchlistShelves.kt@@ -0,0 +1,60 @@+package com.streamvault.feature.catalog.presentation.dashboard++import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistType++/** Projects a Trakt list onto playable items in the active provider's catalog, preserving Trakt order. */+internal fun <T> orderedWatchlistItems(+ watchlistItems: Collection<TraktWatchlistIdentity>,+ type: TraktWatchlistType,+ catalogItems: List<T>,+ tmdbIdOf: (T) -> Long?,+ idOf: (T) -> Long,+ limit: Int+): List<T> {+ if (limit <= 0) return emptyList()++ val catalogByTmdbId = LinkedHashMap<Long, T>()+ catalogItems.forEach { item ->+ tmdbIdOf(item)+ ?.takeIf { it > 0L }+ ?.let { tmdbId ->+ if (!catalogByTmdbId.containsKey(tmdbId)) catalogByTmdbId[tmdbId] = item+ }+ }++ val resolvedIds = HashSet<Long>()+ return buildList {+ for (identity in watchlistItems) {+ if (identity.type != type) continue+ val item = catalogByTmdbId[identity.tmdbId] ?: continue+ if (resolvedIds.add(idOf(item))) add(item)+ if (size == limit) break+ }+ }+}++/** Projects a public Trakt discovery list onto provider items, preserving Trakt rank. */+internal fun <T> orderedDiscoveryItems(+ tmdbIds: List<Long>,+ catalogItems: List<T>,+ tmdbIdOf: (T) -> Long?,+ idOf: (T) -> Long,+ limit: Int,+): List<T> {+ if (limit <= 0) return emptyList()+ val catalogByTmdbId = LinkedHashMap<Long, T>()+ catalogItems.forEach { item ->+ tmdbIdOf(item)?.takeIf { it > 0L }?.let { tmdbId ->+ if (!catalogByTmdbId.containsKey(tmdbId)) catalogByTmdbId[tmdbId] = item+ }+ }+ val resolvedIds = HashSet<Long>()+ return buildList {+ for (tmdbId in tmdbIds) {+ val item = catalogByTmdbId[tmdbId] ?: continue+ if (resolvedIds.add(idOf(item))) add(item)+ if (size == limit) break+ }+ }+}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModel.ktindex 30b3679a..19f5ea98 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModel.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModel.kt@@ -21,6 +21,11 @@ import com.streamvault.domain.repository.MovieRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.SeriesRepository+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteTypeimport com.streamvault.domain.usecase.ContinueWatchingResultimport com.streamvault.domain.usecase.ContinueWatchingScopeimport com.streamvault.domain.usecase.GetContinueWatching@@ -137,7 +142,8 @@ class FavoritesViewModel @Inject constructor(private val playbackHistoryRepository: PlaybackHistoryRepository,private val providerRepository: ProviderRepository,private val preferencesRepository: PreferencesRepository,- private val getContinueWatching: GetContinueWatching+ private val getContinueWatching: GetContinueWatching,+ private val traktFavorites: TraktFavorites,) : ViewModel() {private val _uiState = MutableStateFlow(FavoritesUiState())@@ -425,16 +431,39 @@ class FavoritesViewModel @Inject constructor(contentType = item.favorite.contentType,groupId = item.favorite.groupId)+ val traktSyncFailed = item.favorite.groupId == null && syncTraktFavoriteRemoval(item)_uiState.update {it.copy(itemDialogItem = null,itemMoveTargets = emptyList(),- userMessage = "Removed ${item.title} from this saved view."+ userMessage = if (traktSyncFailed) {+ appContext.getString(R.string.trakt_favorite_sync_failed)+ } else {+ "Removed ${item.title} from this saved view."+ })}}}+ private suspend fun syncTraktFavoriteRemoval(item: FavoriteUiModel): Boolean {+ val identity = when (item.favorite.contentType) {+ ContentType.MOVIE -> movieRepository.getMovie(item.favorite.contentId)?.tmdbId+ ?.takeIf { it > 0L }?.let { TraktFavoriteIdentity(TraktFavoriteType.MOVIE, it) }+ ContentType.SERIES -> seriesRepository.getSeriesById(item.favorite.contentId)?.tmdbId+ ?.takeIf { it > 0L }?.let { TraktFavoriteIdentity(TraktFavoriteType.SHOW, it) }+ else -> null+ } ?: return false++ return when (val result = traktFavorites.setFavorited(identity, favorited = false)) {+ TraktFavoriteActionResult.Success -> false+ is TraktFavoriteActionResult.Failure -> result.reason !in setOf(+ TraktFavoriteFailure.DISCONNECTED,+ TraktFavoriteFailure.INCOGNITO,+ )+ }+ }+fun moveItemToGroup(item: FavoriteUiModel, targetGroupId: Long) {viewModelScope.launch {when (val result = favoriteRepository.moveFavoriteToGroup(diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailScreen.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailScreen.ktindex 6cd8b95a..871a46ff 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailScreen.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailScreen.kt@@ -30,7 +30,9 @@ import androidx.compose.material.icons.outlined.FavoriteBorderimport androidx.compose.runtime.Composableimport androidx.compose.runtime.LaunchedEffectimport androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOfimport androidx.compose.runtime.rememberCoroutineScope+import androidx.compose.runtime.setValueimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifierimport androidx.compose.ui.draw.clip@@ -59,6 +61,11 @@ import com.streamvault.feature.catalog.api.CatalogUiEventimport com.streamvault.feature.catalog.presentation.catalogMessageTextimport com.streamvault.feature.catalog.presentation.components.ExternalRatingsStripimport com.streamvault.feature.catalog.presentation.components.formatVodRatingLabel+import com.streamvault.feature.catalog.presentation.components.TraktWatchlistActionButton+import com.streamvault.feature.catalog.presentation.components.TraktCustomListActionButton+import com.streamvault.feature.catalog.presentation.components.TraktRatingActionButton+import com.streamvault.feature.catalog.presentation.components.TraktRatingDialog+import com.streamvault.feature.catalog.presentation.components.TraktRatingSummaryimport com.streamvault.feature.catalog.presentation.time.formatPositionMsimport com.streamvault.core.ui.device.rememberIsTelevisionDeviceimport com.streamvault.core.ui.image.rememberCrossfadeImageModel@@ -68,6 +75,9 @@ import com.streamvault.core.ui.design.AppColorsimport com.streamvault.core.ui.design.requestFocusSafelyimport com.streamvault.domain.model.ExternalRatingsimport com.streamvault.domain.model.Movie+import com.streamvault.domain.trakt.TraktCustomListItem+import com.streamvault.domain.trakt.TraktCustomListItemIdentity+import com.streamvault.domain.trakt.TraktCustomListItemTypeimport com.streamvault.domain.model.VodMovieVariantimport com.streamvault.core.ui.interaction.TvClickableSurfaceimport com.streamvault.core.ui.interaction.TvButton@@ -86,6 +96,7 @@ fun MovieDetailScreen(val uiState by viewModel.uiState.collectAsStateWithLifecycle()val movie = uiState.movieval context = LocalContext.current+ var ratingDialogOpen by remember(movie?.id) { mutableStateOf(false) }LaunchedEffect(viewModel, context, platformHost) {viewModel.uiEvents.collect { event ->@@ -135,6 +146,15 @@ fun MovieDetailScreen(externalRatings = uiState.externalRatings,isLoadingExternalRatings = uiState.isLoadingExternalRatings,relatedContent = uiState.relatedContent,+ traktWatchlistConnected = uiState.traktWatchlistConnected,+ traktWatchlistLoaded = uiState.traktWatchlistLoaded,+ traktWatchlisted = uiState.traktWatchlisted,+ traktWatchlistBusy = uiState.traktWatchlistBusy,+ onToggleTraktWatchlist = viewModel::toggleTraktWatchlist,+ traktRatingConnected = uiState.traktWatchlistConnected,+ traktUserRating = uiState.traktUserRating,+ traktRatingBusy = uiState.traktRatingBusy,+ onRateOnTrakt = { ratingDialogOpen = true },onPlay = { onPlay(movie) },onCopyUrl = {when (val result = viewModel.resolveCopyStreamUrl()) {@@ -151,6 +171,17 @@ fun MovieDetailScreen(onBack = onBack,viewModel = viewModel)+ if (ratingDialogOpen) {+ TraktRatingDialog(+ currentRating = uiState.traktUserRating,+ busy = uiState.traktRatingBusy,+ onDismiss = { ratingDialogOpen = false },+ onSelect = { rating ->+ ratingDialogOpen = false+ viewModel.rateOnTrakt(rating)+ },+ )+ }}}}@@ -164,6 +195,15 @@ private fun MovieDetailContent(externalRatings: ExternalRatings,isLoadingExternalRatings: Boolean,relatedContent: List<Movie>,+ traktWatchlistConnected: Boolean,+ traktWatchlistLoaded: Boolean,+ traktWatchlisted: Boolean,+ traktWatchlistBusy: Boolean,+ onToggleTraktWatchlist: () -> Unit,+ traktRatingConnected: Boolean,+ traktUserRating: Int?,+ traktRatingBusy: Boolean,+ onRateOnTrakt: () -> Unit,onPlay: () -> Unit,onCopyUrl: suspend () -> String?,onDownload: () -> Unit,@@ -257,6 +297,15 @@ private fun MovieDetailContent(isCasting = isCasting,externalRatings = externalRatings,isLoadingExternalRatings = isLoadingExternalRatings,+ traktWatchlistConnected = traktWatchlistConnected,+ traktWatchlistLoaded = traktWatchlistLoaded,+ traktWatchlisted = traktWatchlisted,+ traktWatchlistBusy = traktWatchlistBusy,+ onToggleTraktWatchlist = onToggleTraktWatchlist,+ traktRatingConnected = traktRatingConnected,+ traktUserRating = traktUserRating,+ traktRatingBusy = traktRatingBusy,+ onRateOnTrakt = onRateOnTrakt,onPlay = onPlay,onCopyUrl = {coroutineScope.launch {@@ -290,6 +339,15 @@ private fun MovieDetailContent(isCasting = isCasting,externalRatings = externalRatings,isLoadingExternalRatings = isLoadingExternalRatings,+ traktWatchlistConnected = traktWatchlistConnected,+ traktWatchlistLoaded = traktWatchlistLoaded,+ traktWatchlisted = traktWatchlisted,+ traktWatchlistBusy = traktWatchlistBusy,+ onToggleTraktWatchlist = onToggleTraktWatchlist,+ traktRatingConnected = traktRatingConnected,+ traktUserRating = traktUserRating,+ traktRatingBusy = traktRatingBusy,+ onRateOnTrakt = onRateOnTrakt,onPlay = onPlay,onCopyUrl = {coroutineScope.launch {@@ -392,6 +450,15 @@ private fun MovieDetailHeroText(isCasting: Boolean,externalRatings: ExternalRatings,isLoadingExternalRatings: Boolean,+ traktWatchlistConnected: Boolean,+ traktWatchlistLoaded: Boolean,+ traktWatchlisted: Boolean,+ traktWatchlistBusy: Boolean,+ onToggleTraktWatchlist: () -> Unit,+ traktRatingConnected: Boolean,+ traktUserRating: Int?,+ traktRatingBusy: Boolean,+ onRateOnTrakt: () -> Unit,onPlay: () -> Unit,onCopyUrl: () -> Unit,onDownload: () -> Unit,@@ -437,6 +504,7 @@ private fun MovieDetailHeroText())+ TraktRatingSummary(traktUserRating)ExternalRatingsStrip(ratings = externalRatings,isLoading = isLoadingExternalRatings@@ -450,78 +518,106 @@ private fun MovieDetailHeroText(onSelectVariant = onSelectVariant)- Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {- TvButton(- onClick = onPlay,- modifier = Modifier.focusRequester(playButtonFocusRequester),- colors = ButtonDefaults.colors(- containerColor = AppColors.Brand,- contentColor = Color.White- )- ) {- Text(- text = if (hasResume) {- stringResource(R.string.movie_detail_resume_from, formatPositionMs(resumePositionMs))- } else {- stringResource(R.string.movie_detail_play)- }- )- }- TvButton(- onClick = onCopyUrl,- colors = ButtonDefaults.colors(- containerColor = AppColors.SurfaceEmphasis,- contentColor = AppColors.TextPrimary- )- ) {- Text(stringResource(R.string.stream_url_copy))- }- TvButton(- onClick = onDownload,- colors = ButtonDefaults.colors(- containerColor = AppColors.SurfaceEmphasis,- contentColor = AppColors.TextPrimary- )- ) {- Text(stringResource(R.string.download_button_label))- }- TvButton(- onClick = onCast,- enabled = !isCasting,- colors = ButtonDefaults.colors(- containerColor = AppColors.SurfaceEmphasis,- contentColor = AppColors.TextPrimary- )- ) {- Text(- stringResource(- if (isCasting) R.string.cast_launching else R.string.cast_button_label+ Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {+ TvButton(+ onClick = onPlay,+ modifier = Modifier.focusRequester(playButtonFocusRequester),+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Brand,+ contentColor = Color.White)- )- }- if (hasTrailer) {+ ) {+ Text(+ text = if (hasResume) {+ stringResource(R.string.movie_detail_resume_from, formatPositionMs(resumePositionMs))+ } else {+ stringResource(R.string.movie_detail_play)+ }+ )+ }TvButton(- onClick = onPlayTrailer,+ onClick = onCopyUrl,colors = ButtonDefaults.colors(containerColor = AppColors.SurfaceEmphasis,contentColor = AppColors.TextPrimary)) {- Text(stringResource(R.string.movie_detail_trailer))+ Text(stringResource(R.string.stream_url_copy))+ }+ TvButton(+ onClick = onDownload,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary+ )+ ) {+ Text(stringResource(R.string.download_button_label))+ }+ TvButton(+ onClick = onCast,+ enabled = !isCasting,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary+ )+ ) {+ Text(+ stringResource(+ if (isCasting) R.string.cast_launching else R.string.cast_button_label+ )+ )+ }+ if (hasTrailer) {+ TvButton(+ onClick = onPlayTrailer,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary+ )+ ) {+ Text(stringResource(R.string.movie_detail_trailer))+ }}}- TvIconButton(- onClick = onToggleFavorite,- colors = ButtonDefaults.colors(- containerColor = if (movie.isFavorite) AppColors.Brand else AppColors.SurfaceEmphasis,- contentColor = if (movie.isFavorite) Color.White else AppColors.TextSecondary- )- ) {- Icon(- imageVector = if (movie.isFavorite) Icons.Filled.Favorite else Icons.Outlined.FavoriteBorder,- contentDescription = stringResource(- if (movie.isFavorite) R.string.favorites_remove else R.string.favorites_add+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {+ TvIconButton(+ onClick = onToggleFavorite,+ colors = ButtonDefaults.colors(+ containerColor = if (movie.isFavorite) AppColors.Brand else AppColors.SurfaceEmphasis,+ contentColor = if (movie.isFavorite) Color.White else AppColors.TextSecondary)+ ) {+ Icon(+ imageVector = if (movie.isFavorite) Icons.Filled.Favorite else Icons.Outlined.FavoriteBorder,+ contentDescription = stringResource(+ if (movie.isFavorite) R.string.favorites_remove else R.string.favorites_add+ )+ )+ }+ TraktWatchlistActionButton(+ hasIdentity = movie.tmdbId?.let { it > 0L } == true,+ connected = traktWatchlistConnected,+ loaded = traktWatchlistLoaded,+ watchlisted = traktWatchlisted,+ busy = traktWatchlistBusy,+ onClick = onToggleTraktWatchlist,+ )+ TraktRatingActionButton(+ hasIdentity = movie.tmdbId?.let { it > 0L } == true,+ connected = traktRatingConnected,+ busy = traktRatingBusy,+ rating = traktUserRating,+ onClick = onRateOnTrakt,+ )+ TraktCustomListActionButton(+ movie.tmdbId?.takeIf { it > 0L }?.let { tmdbId ->+ TraktCustomListItem(+ identity = TraktCustomListItemIdentity(TraktCustomListItemType.MOVIE, tmdbId),+ title = movie.name,+ year = movie.releaseDate?.take(4)?.toIntOrNull(),+ )+ },)}}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModel.ktindex f69a881c..24d117d4 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModel.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModel.kt@@ -28,6 +28,21 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.MovieRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepository+import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistActionResult+import com.streamvault.domain.trakt.TraktWatchlistFailure+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistRefreshResult+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktRatings+import com.streamvault.domain.trakt.TraktRatingActionResult+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingTypeimport dagger.hilt.android.lifecycle.HiltViewModelimport javax.inject.Injectimport kotlinx.coroutines.flow.MutableStateFlow@@ -52,7 +67,10 @@ class MovieDetailViewModel @Inject constructor(private val streamPreparer: CatalogStreamPreparer,private val downloadManager: DownloadManager,private val downloadStarter: CatalogDownloadStarter,- private val castPort: CatalogCastPort+ private val castPort: CatalogCastPort,+ private val traktWatchlist: TraktWatchlist,+ private val traktFavorites: TraktFavorites,+ private val traktRatings: TraktRatings,) : ViewModel() {private val movieId: Long = checkNotNull(@@ -73,9 +91,72 @@ class MovieDetailViewModel @Inject constructor(init {observeCastPlaybackEvents()+ observeTraktWatchlist()+ observeTraktRatings()loadMovieDetails()}+ private fun observeTraktWatchlist() {+ viewModelScope.launch {+ traktWatchlist.state.collect { watchlistState ->+ _uiState.update { current ->+ val identity = current.movie?.tmdbId?.takeIf { it > 0L }+ ?.let { TraktWatchlistIdentity(TraktWatchlistType.MOVIE, it) }+ current.copy(+ traktWatchlistConnected = watchlistState.connected,+ traktWatchlistLoaded = watchlistState.loaded,+ traktWatchlisted = watchlistState.loaded && identity?.let(watchlistState::contains) == true,+ traktWatchlistBusy = watchlistState.isRefreshing ||+ (identity != null && identity in watchlistState.updating),+ traktWatchlistFailure = watchlistState.failure,+ )+ }+ }+ }+ }++ private fun refreshTraktWatchlist() {+ if (_uiState.value.movie?.tmdbId?.let { it > 0L } != true) return+ viewModelScope.launch { traktWatchlist.refresh() }+ }++ private fun observeTraktRatings() {+ viewModelScope.launch {+ traktRatings.state.collect { ratingsState ->+ _uiState.update { current ->+ val identity = current.movie?.tmdbId?.takeIf { it > 0L }+ ?.let { TraktRatingIdentity(TraktRatingType.MOVIE, it) }+ current.copy(+ traktUserRating = identity?.let(ratingsState::rating),+ traktRatingBusy = ratingsState.refreshing.contains(TraktRatingType.MOVIE) ||+ (identity != null && identity in ratingsState.updating),+ )+ }+ }+ }+ }++ private fun refreshTraktRatings() {+ _uiState.value.movie?.tmdbId?.takeIf { it > 0L } ?: return+ viewModelScope.launch { traktRatings.refresh(TraktRatingType.MOVIE) }+ }++ fun toggleTraktWatchlist() {+ val movie = _uiState.value.movie ?: return+ val tmdbId = movie.tmdbId?.takeIf { it > 0L } ?: return+ val identity = TraktWatchlistIdentity(TraktWatchlistType.MOVIE, tmdbId)+ viewModelScope.launch {+ val result = if (!_uiState.value.traktWatchlistLoaded) {+ traktWatchlist.refresh(force = true)+ } else {+ traktWatchlist.setWatchlisted(identity, !_uiState.value.traktWatchlisted)+ }+ if (result is TraktWatchlistRefreshResult.Failure || result is TraktWatchlistActionResult.Failure) {+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktWatchlistFailed))+ }+ }+ }+private fun loadMovieDetails() {viewModelScope.launch {try {@@ -140,6 +221,38 @@ class MovieDetailViewModel @Inject constructor(favoriteRepository.removeFavorite(movie.providerId, movie.id, ContentType.MOVIE)}_uiState.update { it.copy(movie = movie.copy(isFavorite = newState)) }+ movie.tmdbId?.takeIf { it > 0L }?.let { tmdbId ->+ when (val result = traktFavorites.setFavorited(+ TraktFavoriteIdentity(TraktFavoriteType.MOVIE, tmdbId), newState,+ )) {+ TraktFavoriteActionResult.Success -> Unit+ is TraktFavoriteActionResult.Failure -> if (result.reason != TraktFavoriteFailure.DISCONNECTED &&+ result.reason != TraktFavoriteFailure.INCOGNITO) {+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktFavoriteSyncFailed))+ }+ }+ }+ }+ }++ fun rateOnTrakt(rating: Int) {+ val movie = _uiState.value.movie ?: return+ val tmdbId = movie.tmdbId?.takeIf { it > 0L } ?: return+ if (rating !in 1..10 || _uiState.value.traktRatingBusy) return+ viewModelScope.launch {+ _uiState.update { it.copy(traktRatingBusy = true) }+ try {+ when (traktRatings.setRating(TraktRatingIdentity(TraktRatingType.MOVIE, tmdbId), rating)) {+ TraktRatingActionResult.Success -> {+ _uiState.update { it.copy(traktUserRating = rating) }+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktRatingSaved))+ }+ is TraktRatingActionResult.Failure ->+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktRatingFailed))+ }+ } finally {+ _uiState.update { it.copy(traktRatingBusy = false) }+ }}}@@ -332,6 +445,8 @@ class MovieDetailViewModel @Inject constructor(resumePositionMs = if (hasResume) resumePositionMs else 0L)}+ refreshTraktWatchlist()+ refreshTraktRatings()}}@@ -344,7 +459,14 @@ data class MovieDetailUiState(val isCasting: Boolean = false,val isLoadingExternalRatings: Boolean = false,val externalRatings: ExternalRatings = ExternalRatings.unavailable(),- val relatedContent: List<Movie> = emptyList()+ val relatedContent: List<Movie> = emptyList(),+ val traktWatchlistConnected: Boolean = false,+ val traktWatchlistLoaded: Boolean = false,+ val traktWatchlisted: Boolean = false,+ val traktWatchlistBusy: Boolean = false,+ val traktWatchlistFailure: TraktWatchlistFailure? = null,+ val traktUserRating: Int? = null,+ val traktRatingBusy: Boolean = false,)private enum class CastPlaybackReportMode {diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesScreen.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesScreen.ktindex bb3f1fc4..7191fe81 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesScreen.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesScreen.kt@@ -43,6 +43,7 @@ import com.streamvault.core.ui.device.rememberIsTelevisionDeviceimport com.streamvault.feature.catalog.presentation.components.CategoryRowimport com.streamvault.feature.catalog.presentation.components.ContinueWatchingRowimport com.streamvault.feature.catalog.presentation.components.MovieCard+import com.streamvault.feature.catalog.presentation.components.TraktRatingSummaryimport com.streamvault.feature.catalog.presentation.components.SelectionChipimport com.streamvault.feature.catalog.presentation.components.SelectionChipRowimport com.streamvault.feature.catalog.presentation.components.SavedCategoryContextCard@@ -378,6 +379,9 @@ private fun MoviesVodContent(else -> 300.dp}var showCategoryPicker by remember { mutableStateOf(false) }+ val traktWatchlistLabel = stringResource(R.string.dashboard_trakt_watchlist_movies)+ val traktTrendingLabel = stringResource(R.string.trakt_discovery_trending_movies)+ val traktPopularLabel = stringResource(R.string.trakt_discovery_popular_movies)val favoriteMovies = uiState.moviesByCategory[uiState.favoriteCategoryName].orEmpty()val freshMovies = uiState.libraryLensRows[MovieLibraryLens.FRESH].orEmpty()val topRatedMovies = uiState.libraryLensRows[MovieLibraryLens.TOP_RATED].orEmpty()@@ -465,21 +469,67 @@ private fun MoviesVodContent(?: topRatedMovies.firstOrNull()?.id?: catEntries.firstOrNull()?.value?.firstOrNull()?.id} else null- val categoryOptions = remember(visibleCategoryNames, uiState.categoryCounts, categoryByName, uiState.parentalControlLevel, uiState.unlockedCategoryIds) {- visibleCategoryNames.map { name ->- val matchedCategory = categoryByName[name]- val lockedCategory = matchedCategory?.takeIf(isCategoryLocked)- VodCategoryOption(- name = name,- count = uiState.categoryCounts[name] ?: 0,- onClick = {- if (lockedCategory != null) openProtectedCategory(lockedCategory) else onSelectCategory(name)- },- onLongClick = matchedCategory?.takeIf { lockedCategory == null }?.let { category ->- { onShowCategoryOptions(category.name) }- },- isLocked = lockedCategory != null- )+ val categoryOptions = remember(+ visibleCategoryNames,+ uiState.categoryCounts,+ categoryByName,+ uiState.parentalControlLevel,+ uiState.unlockedCategoryIds,+ uiState.traktWatchlistConnected,+ uiState.traktWatchlistCount,+ uiState.traktTrendingCount,+ uiState.traktPopularCount,+ uiState.showTraktTrendingMovies,+ uiState.showTraktPopularMovies,+ traktTrendingLabel,+ traktPopularLabel,+ traktWatchlistLabel+ ) {+ buildList {+ visibleCategoryNames.forEach { name ->+ val matchedCategory = categoryByName[name]+ val lockedCategory = matchedCategory?.takeIf(isCategoryLocked)+ add(+ VodCategoryOption(+ name = name,+ count = uiState.categoryCounts[name] ?: 0,+ onClick = {+ if (lockedCategory != null) openProtectedCategory(lockedCategory) else onSelectCategory(name)+ },+ onLongClick = matchedCategory?.takeIf { lockedCategory == null }?.let { category ->+ { onShowCategoryOptions(category.name) }+ },+ isLocked = lockedCategory != null+ )+ )+ }+ if (uiState.traktWatchlistConnected) {+ add(+ VodCategoryOption(+ name = traktWatchlistLabel,+ count = uiState.traktWatchlistCount,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktTrendingMovies) {+ add(+ VodCategoryOption(+ name = traktTrendingLabel,+ count = uiState.traktTrendingCount,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktPopularMovies) {+ add(+ VodCategoryOption(+ name = traktPopularLabel,+ count = uiState.traktPopularCount,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY) }+ )+ )+ }}}@@ -570,6 +620,35 @@ private fun MoviesVodContent(onClick = { showCategoryPicker = true }))+ if (uiState.traktWatchlistConnected) {+ add(+ VodActionChip(+ key = VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY,+ label = traktWatchlistLabel,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktTrendingMovies) {+ add(+ VodActionChip(+ key = VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY,+ label = traktTrendingLabel,+ detail = uiState.traktTrendingCount.takeIf { it > 0 }?.toString(),+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktPopularMovies) {+ add(+ VodActionChip(+ key = VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY,+ label = traktPopularLabel,+ detail = uiState.traktPopularCount.takeIf { it > 0 }?.toString(),+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY) }+ )+ )+ }if (favoriteMovies.isNotEmpty()) {add(VodActionChip(@@ -821,6 +900,9 @@ private fun MoviesVodContent(VodSectionHeader(title = when (uiState.selectedCategory) {uiState.fullLibraryCategoryName -> stringResource(R.string.library_full_browse_title_movies)+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> traktWatchlistLabel+ VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY -> traktTrendingLabel+ VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY -> traktPopularLabelelse -> uiState.selectedCategory ?: stringResource(R.string.nav_movies)})@@ -922,7 +1004,17 @@ private fun MoviesVodContent() {AppMessageState(title = stringResource(R.string.movies_no_found),- subtitle = stringResource(R.string.movies_no_found_subtitle)+ subtitle = stringResource(+ when (uiState.selectedCategory) {+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> R.string.trakt_watchlist_movies_no_matches+ VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY,+ VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY -> if (+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY && uiState.traktTrendingFailed) ||+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY && uiState.traktPopularFailed)+ ) R.string.trakt_discovery_load_failed else R.string.trakt_discovery_movies_no_matches+ else -> R.string.movies_no_found_subtitle+ }+ ))}}@@ -1020,6 +1112,9 @@ private fun MoviesVodClassicContent(val allLabel = stringResource(R.string.vod_classic_all)val continueLabel = stringResource(R.string.vod_classic_continue_watching)val recentLabel = stringResource(R.string.vod_classic_recently_added)+ val traktWatchlistLabel = stringResource(R.string.dashboard_trakt_watchlist_movies)+ val traktTrendingLabel = stringResource(R.string.trakt_discovery_trending_movies)+ val traktPopularLabel = stringResource(R.string.trakt_discovery_popular_movies)val categoryByName = remember(uiState.providerCategories, uiState.categories, uiState.favoriteCategoryName) {buildMap<String, Category> {uiState.providerCategories.forEach { put(it.name, it) }@@ -1110,6 +1205,9 @@ private fun MoviesVodClassicContent(}val selectedKey = when {+ uiState.selectedCategory == VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> "trakt_watchlist"+ uiState.selectedCategory == VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY -> "trakt_trending"+ uiState.selectedCategory == VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY -> "trakt_popular"uiState.selectedCategory == uiState.favoriteCategoryName -> "favorites"uiState.selectedCategory == uiState.fullLibraryCategoryName && selectedFilterType == LibraryFilterType.IN_PROGRESS -> "continue"uiState.selectedCategory == uiState.fullLibraryCategoryName && selectedFilterType == LibraryFilterType.RECENTLY_UPDATED -> "recent"@@ -1145,7 +1243,16 @@ private fun MoviesVodClassicContent(recentCount,uiState.libraryCount,uiState.unlockedCategoryIds,- uiState.parentalControlLevel+ uiState.parentalControlLevel,+ uiState.traktWatchlistConnected,+ uiState.traktWatchlistCount,+ uiState.traktTrendingCount,+ uiState.traktPopularCount,+ uiState.showTraktTrendingMovies,+ uiState.showTraktPopularMovies,+ traktTrendingLabel,+ traktPopularLabel,+ traktWatchlistLabel) {buildList {add(@@ -1166,6 +1273,39 @@ private fun MoviesVodClassicContent(onClick = { onSelectCategory(uiState.favoriteCategoryName) }))+ if (uiState.traktWatchlistConnected) {+ add(+ VodClassicCategoryOption(+ key = "trakt_watchlist",+ label = traktWatchlistLabel,+ count = uiState.traktWatchlistCount,+ isSelected = selectedKey == "trakt_watchlist",+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktTrendingMovies) {+ add(+ VodClassicCategoryOption(+ key = "trakt_trending",+ label = traktTrendingLabel,+ count = uiState.traktTrendingCount,+ isSelected = selectedKey == "trakt_trending",+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktPopularMovies) {+ add(+ VodClassicCategoryOption(+ key = "trakt_popular",+ label = traktPopularLabel,+ count = uiState.traktPopularCount,+ isSelected = selectedKey == "trakt_popular",+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY) }+ )+ )+ }add(VodClassicCategoryOption(key = "continue",@@ -1225,6 +1365,9 @@ private fun MoviesVodClassicContent(selectedKey == "all" -> allLabelselectedKey == "continue" -> continueLabelselectedKey == "recent" -> recentLabel+ selectedKey == "trakt_watchlist" -> traktWatchlistLabel+ selectedKey == "trakt_trending" -> traktTrendingLabel+ selectedKey == "trakt_popular" -> traktPopularLabelelse -> uiState.selectedCategory ?: allLabel},subtitle = stringResource(@@ -1307,7 +1450,17 @@ private fun MoviesVodClassicContent(item(span = { GridItemSpan(maxLineSpan) }) {AppMessageState(title = stringResource(R.string.movies_no_found),- subtitle = stringResource(R.string.vod_classic_empty_category)+ subtitle = stringResource(+ when (uiState.selectedCategory) {+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> R.string.trakt_watchlist_movies_no_matches+ VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY,+ VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY -> if (+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY && uiState.traktTrendingFailed) ||+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY && uiState.traktPopularFailed)+ ) R.string.trakt_discovery_load_failed else R.string.trakt_discovery_movies_no_matches+ else -> R.string.vod_classic_empty_category+ }+ ))}} else {diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.ktindex a7b99557..063ee840 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt@@ -23,6 +23,20 @@ import com.streamvault.domain.repository.MovieRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.M3uClassificationRepository+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistRefreshResult+import com.streamvault.domain.trakt.TraktWatchlistState+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktDiscovery+import com.streamvault.domain.trakt.TraktDiscoveryRefreshResult+import com.streamvault.domain.trakt.TraktDiscoveryStateimport com.streamvault.domain.usecase.ContinueWatchingResultimport com.streamvault.domain.usecase.ContinueWatchingScopeimport com.streamvault.domain.usecase.GetContinueWatching@@ -44,6 +58,8 @@ import com.streamvault.feature.catalog.presentation.vod.setVodSearchQueryimport com.streamvault.feature.catalog.presentation.vod.setVodFavoriteimport com.streamvault.feature.catalog.presentation.vod.updateVodGroupMembershipimport com.streamvault.feature.catalog.presentation.vod.VodBrowseDefaults+import com.streamvault.feature.catalog.presentation.dashboard.orderedWatchlistItems+import com.streamvault.feature.catalog.presentation.dashboard.orderedDiscoveryItemsimport com.streamvault.domain.playback.isPlaybackCompleteimport dagger.hilt.android.lifecycle.HiltViewModelimport javax.inject.Inject@@ -84,7 +100,11 @@ class MoviesViewModel @Inject constructor(private val getContinueWatching: GetContinueWatching,private val getCustomCategories: GetCustomCategories,private val parentalControlManager: ParentalControlManager,- private val m3uClassificationRepository: M3uClassificationRepository+ private val m3uClassificationRepository: M3uClassificationRepository,+ private val traktFavorites: TraktFavorites,+ private val traktAccount: TraktAccount,+ private val traktWatchlist: TraktWatchlist,+ private val traktDiscovery: TraktDiscovery,) : ViewModel() {private companion object {const val UNCATEGORIZED = "Uncategorized"@@ -144,6 +164,81 @@ class MoviesViewModel @Inject constructor(}}+ viewModelScope.launch {+ runCatching { traktAccount.load() }+ traktAccount.state+ .map { state -> state.username.takeIf { state.connected } }+ .distinctUntilChanged()+ .collectLatest { username ->+ _uiState.update { it.copy(traktWatchlistConnected = username != null) }+ if (username != null) traktWatchlist.refresh()+ }+ }++ viewModelScope.launch {+ combine(traktAccount.state, traktWatchlist.state) { account, watchlist ->+ val watchlistBelongsToAccount = account.connected &&+ account.username != null &&+ account.username == watchlist.accountUsername+ account.connected to if (watchlistBelongsToAccount) {+ watchlist.items.count { it.type == TraktWatchlistType.MOVIE }+ } else {+ 0+ }+ }.collect { (connected, count) ->+ _uiState.update {+ it.copy(traktWatchlistConnected = connected, traktWatchlistCount = count)+ }+ }+ }++ viewModelScope.launch {+ traktDiscovery.state.collect { discovery ->+ _uiState.update {+ it.copy(+ traktTrendingCount = discovery.items(VodBrowseDefaults.TRAKT_TRENDING_MOVIES).size,+ traktPopularCount = discovery.items(VodBrowseDefaults.TRAKT_POPULAR_MOVIES).size,+ traktTrendingFailed = VodBrowseDefaults.TRAKT_TRENDING_MOVIES in discovery.failed,+ traktPopularFailed = VodBrowseDefaults.TRAKT_POPULAR_MOVIES in discovery.failed,+ )+ }+ }+ }++ viewModelScope.launch {+ combine(+ preferencesRepository.showTraktTrendingMovies,+ preferencesRepository.showTraktPopularMovies,+ preferencesRepository.showTraktTrendingSeries,+ preferencesRepository.showTraktPopularSeries+ ) { trendingMovies, popularMovies, trendingSeries, popularSeries ->+ listOf(trendingMovies, popularMovies, trendingSeries, popularSeries)+ }.distinctUntilChanged().collect { visibility ->+ val showTrending = visibility[0]+ val showPopular = visibility[1]+ _uiState.update { state ->+ val hideSelectedCategory = when (state.selectedCategory) {+ VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY -> !showTrending+ VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY -> !showPopular+ else -> false+ }+ state.copy(+ showTraktTrendingMovies = showTrending,+ showTraktPopularMovies = showPopular,+ showTraktTrendingSeries = visibility[2],+ showTraktPopularSeries = visibility[3],+ selectedCategory = if (hideSelectedCategory) null else state.selectedCategory,+ selectedCategoryItems = if (hideSelectedCategory) emptyList() else state.selectedCategoryItems,+ selectedCategoryLoadedCount = if (hideSelectedCategory) 0 else state.selectedCategoryLoadedCount,+ selectedCategoryTotalCount = if (hideSelectedCategory) 0 else state.selectedCategoryTotalCount,+ canLoadMoreSelectedCategory = if (hideSelectedCategory) false else state.canLoadMoreSelectedCategory,+ isLoadingSelectedCategory = if (hideSelectedCategory) false else state.isLoadingSelectedCategory,+ isLoadingMoreSelectedCategory = if (hideSelectedCategory) false else state.isLoadingMoreSelectedCategory+ )+ }+ }+ }+viewModelScope.launch {try {providerRepository.getActiveProvider()@@ -374,6 +469,15 @@ class MoviesViewModel @Inject constructor(providerCategoryCounts = providerCategoryCounts,hiddenCategoryIds = hiddenCategoryIds)+ }.combine(+ combine(traktAccount.state, traktWatchlist.state) { account, watchlist -> account to watchlist }+ ) { dependencies, traktState ->+ dependencies.copy(+ traktAccountState = traktState.first,+ traktWatchlistState = traktState.second+ )+ }.combine(traktDiscovery.state) { dependencies, discoveryState ->+ dependencies.copy(traktDiscoveryState = discoveryState)}.combine(combine(_uiState.map { it.selectedCategory }.distinctUntilChanged(),@@ -406,7 +510,10 @@ class MoviesViewModel @Inject constructor(?.id?.let { categoryId -> (dependencies.providerCategoryCounts[categoryId] ?: 0) > 0 }?: false,- hiddenCategoryIds = dependencies.hiddenCategoryIds+ hiddenCategoryIds = dependencies.hiddenCategoryIds,+ traktAccountState = dependencies.traktAccountState,+ traktWatchlistState = dependencies.traktWatchlistState,+ traktDiscoveryState = dependencies.traktDiscoveryState)}}@@ -423,7 +530,8 @@ class MoviesViewModel @Inject constructor(selectedCategoryLoadedCount = snapshot.loadedCount,selectedCategoryTotalCount = snapshot.totalCount,canLoadMoreSelectedCategory = snapshot.canLoadMore,- isLoadingSelectedCategory = initialRemoteRequestInFlight && snapshot.items.isEmpty()+ isLoadingSelectedCategory = snapshot.isLoading ||+ (initialRemoteRequestInFlight && snapshot.items.isEmpty()))}}@@ -582,6 +690,34 @@ class MoviesViewModel @Inject constructor(isLoadingSelectedCategory = isLoadingSelectedCategory)}+ if (categoryName == VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) {+ viewModelScope.launch {+ when (val result = traktWatchlist.refresh()) {+ is TraktWatchlistRefreshResult.Success -> Unit+ is TraktWatchlistRefreshResult.Failure -> {+ _uiState.update {+ it.copy(+ userMessage = if (result.reason == com.streamvault.domain.trakt.TraktWatchlistFailure.DISCONNECTED) {+ "Connect Trakt in Settings to view your watchlist."+ } else {+ "Could not load the Trakt watchlist. Try again."+ }+ )+ }+ }+ }+ }+ return+ }+ val discoveryCategory = VodBrowseDefaults.traktDiscoveryCategory(categoryName)+ if (discoveryCategory != null) {+ viewModelScope.launch {+ if (traktDiscovery.refresh(discoveryCategory) is TraktDiscoveryRefreshResult.Failure) {+ _uiState.update { it.copy(userMessage = "Could not load Trakt discovery titles. Try again.") }+ }+ }+ return+ }val providerId = activeProviderId ?: returnval categoryId = resolveProviderCategoryId(categoryName) ?: returninitialRemoteRequestInFlight = true@@ -783,6 +919,7 @@ class MoviesViewModel @Inject constructor(viewModelScope.launch {setVodFavorite(movie.providerId, movie.selectedRawMovieId(), ContentType.MOVIE, true, favoriteRepository)_uiState.update { it.copy(selectedMovieForDialog = movie.copy(isFavorite = true)) }+ syncTraktFavorite(movie.tmdbId, true)}}@@ -792,6 +929,20 @@ class MoviesViewModel @Inject constructor(setVodFavorite(movie.providerId, rawMovieId, ContentType.MOVIE, false, favoriteRepository)}_uiState.update { it.copy(selectedMovieForDialog = movie.copy(isFavorite = false)) }+ syncTraktFavorite(movie.tmdbId, false)+ }+ }++ private suspend fun syncTraktFavorite(tmdbId: Long?, favorited: Boolean) {+ val id = tmdbId?.takeIf { it > 0L } ?: return+ when (val result = traktFavorites.setFavorited(TraktFavoriteIdentity(TraktFavoriteType.MOVIE, id), favorited)) {+ TraktFavoriteActionResult.Success -> Unit+ is TraktFavoriteActionResult.Failure -> if (result.reason != TraktFavoriteFailure.DISCONNECTED &&+ result.reason != TraktFavoriteFailure.INCOGNITO) {+ _uiState.update {+ it.copy(userMessage = "StreamVault saved the change, but could not update Trakt Favorites. Try again.")+ }+ }}}@@ -1179,6 +1330,58 @@ class MoviesViewModel @Inject constructor(.toSet()val (selectedItems, totalCount, hasMoreRemote) = when (request.selectedCategory) {+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> {+ val account = request.traktAccountState+ val watchlist = request.traktWatchlistState+ if (!account.connected || account.username == null ||+ account.username != watchlist.accountUsername || !watchlist.loaded+ ) {+ Triple(emptyList<Movie>(), 0, false)+ } else {+ val watchlistTmdbIds = watchlist.items.asSequence()+ .filter { it.type == TraktWatchlistType.MOVIE }+ .map { it.tmdbId }+ .toList()+ val catalogItems = movieRepository.getMoviesByTmdbIds(request.providerId, watchlistTmdbIds)+ .filterNot { movie -> movie.categoryId in request.hiddenCategoryIds }+ val watchlistMovies = orderedWatchlistItems(+ watchlistItems = watchlist.items,+ type = TraktWatchlistType.MOVIE,+ catalogItems = catalogItems,+ tmdbIdOf = Movie::tmdbId,+ idOf = Movie::id,+ limit = Int.MAX_VALUE+ )+ val filteredItems = applyLocalBrowseToMovies(+ watchlistMovies,+ request.filterType,+ request.sortBy,+ effectiveQuery+ )+ Triple(filteredItems.take(request.loadLimit), filteredItems.size, false)+ }+ }+ VodBrowseDefaults.TRAKT_TRENDING_MOVIES_CATEGORY,+ VodBrowseDefaults.TRAKT_POPULAR_MOVIES_CATEGORY -> {+ val discoveryCategory = requireNotNull(VodBrowseDefaults.traktDiscoveryCategory(request.selectedCategory))+ val tmdbIds = request.traktDiscoveryState.items(discoveryCategory)+ val catalogItems = movieRepository.getMoviesByTmdbIds(request.providerId, tmdbIds)+ .filterNot { movie -> movie.categoryId in request.hiddenCategoryIds }+ val discoveryMovies = orderedDiscoveryItems(+ tmdbIds = tmdbIds,+ catalogItems = catalogItems,+ tmdbIdOf = Movie::tmdbId,+ idOf = Movie::id,+ limit = Int.MAX_VALUE+ )+ val filteredItems = applyLocalBrowseToMovies(+ discoveryMovies,+ request.filterType,+ request.sortBy,+ effectiveQuery+ )+ Triple(filteredItems.take(request.loadLimit), filteredItems.size, false)+ }VodBrowseDefaults.FULL_LIBRARY_CATEGORY -> {val result = movieRepository.browseMovies(@@ -1290,7 +1493,12 @@ class MoviesViewModel @Inject constructor(items = enrichedItems,loadedCount = enrichedItems.size,totalCount = totalCount,- canLoadMore = totalCount > enrichedItems.size || hasMoreRemote+ canLoadMore = totalCount > enrichedItems.size || hasMoreRemote,+ isLoading = request.selectedCategory == VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY &&+ request.traktWatchlistState.isRefreshing ||+ VodBrowseDefaults.traktDiscoveryCategory(request.selectedCategory)?.let {+ it in request.traktDiscoveryState.refreshing+ } == true)}@@ -1412,7 +1620,10 @@ private data class MovieCategorySelectionDependencies(val customCategories: List<Category>,val providerCategories: List<Category>,val providerCategoryCounts: Map<Long, Int>,- val hiddenCategoryIds: Set<Long>+ val hiddenCategoryIds: Set<Long>,+ val traktAccountState: TraktAccountState = TraktAccountState(),+ val traktWatchlistState: TraktWatchlistState = TraktWatchlistState(),+ val traktDiscoveryState: TraktDiscoveryState = TraktDiscoveryState())private data class SelectedMovieCategoryRequest(@@ -1426,7 +1637,10 @@ private data class SelectedMovieCategoryRequest(val customCategories: List<Category>,val providerCategories: List<Category>,val selectedProviderCategoryHasItems: Boolean,- val hiddenCategoryIds: Set<Long>+ val hiddenCategoryIds: Set<Long>,+ val traktAccountState: TraktAccountState,+ val traktWatchlistState: TraktWatchlistState,+ val traktDiscoveryState: TraktDiscoveryState)private data class SelectedMovieBrowseSelection(@@ -1441,7 +1655,8 @@ private data class SelectedMovieCategorySnapshot(val items: List<Movie> = emptyList(),val loadedCount: Int = 0,val totalCount: Int = 0,- val canLoadMore: Boolean = false+ val canLoadMore: Boolean = false,+ val isLoading: Boolean = false)data class MoviesUiState(@@ -1449,6 +1664,16 @@ data class MoviesUiState(val categoryNames: List<String> = emptyList(),val categoryCounts: Map<String, Int> = emptyMap(),val libraryCount: Int = 0,+ val traktWatchlistConnected: Boolean = false,+ val traktWatchlistCount: Int = 0,+ val traktTrendingCount: Int = 0,+ val traktPopularCount: Int = 0,+ val traktTrendingFailed: Boolean = false,+ val traktPopularFailed: Boolean = false,+ val showTraktTrendingMovies: Boolean = true,+ val showTraktPopularMovies: Boolean = true,+ val showTraktTrendingSeries: Boolean = true,+ val showTraktPopularSeries: Boolean = true,val favoriteCategoryName: String = "\u2605 Favorites",val fullLibraryCategoryName: String = "__full_library__",val libraryLensRows: Map<MovieLibraryLens, List<Movie>> = emptyMap(),diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/search/SearchScreen.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/search/SearchScreen.ktindex 1c4fdf7c..ece98f85 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/search/SearchScreen.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/search/SearchScreen.kt@@ -12,6 +12,8 @@ import androidx.compose.foundation.lazy.LazyRowimport androidx.compose.foundation.lazy.itemsimport androidx.compose.foundation.shape.CircleShapeimport androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.material3.SnackbarHost+import androidx.compose.material3.SnackbarHostStateimport androidx.lifecycle.compose.collectAsStateWithLifecycleimport androidx.compose.runtime.*import androidx.compose.ui.Alignment@@ -68,6 +70,11 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.usecase.SearchContentimport com.streamvault.domain.usecase.SearchContentScope+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteTypeimport com.streamvault.domain.manager.RecordingManagerimport com.streamvault.domain.model.RecordingStatusimport com.streamvault.domain.util.AdultContentVisibilityPolicy@@ -89,7 +96,8 @@ class SearchViewModel @Inject constructor(private val parentalControlManager: ParentalControlManager,private val favoriteRepository: FavoriteRepository,private val categoryRepository: CategoryRepository,- private val recordingManager: RecordingManager+ private val recordingManager: RecordingManager,+ private val traktFavorites: TraktFavorites,) : ViewModel() {private companion object {const val MAX_RESULTS_PER_SECTION = 120@@ -111,6 +119,9 @@ class SearchViewModel @Inject constructor(private val _scheduledChannelIds = MutableStateFlow<Set<Long>>(emptySet())val scheduledChannelIds: StateFlow<Set<Long>> = _scheduledChannelIds.asStateFlow()+ private val _userMessages = MutableSharedFlow<String>(extraBufferCapacity = 1)+ val userMessages = _userMessages.asSharedFlow()+private val unlockedCategoryIds = providerRepository.getActiveProvider().onEach { provider -> _activeProviderId.value = provider?.id }.flatMapLatest { provider ->@@ -280,14 +291,35 @@ class SearchViewModel @Inject constructor(// ג”€ג”€ Search item long-press actions ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€- fun toggleFavorite(contentId: Long, contentType: ContentType, currentlyFavorite: Boolean) {+ fun toggleFavorite(+ contentId: Long,+ contentType: ContentType,+ currentlyFavorite: Boolean,+ tmdbId: Long? = null,+ ) {viewModelScope.launch {val providerId = _activeProviderId.value ?: return@launch+ val favorited = !currentlyFavoriteif (currentlyFavorite) {favoriteRepository.removeFavorite(providerId, contentId, contentType)} else {favoriteRepository.addFavorite(providerId, contentId, contentType)}+ val traktType = when (contentType) {+ ContentType.MOVIE -> TraktFavoriteType.MOVIE+ ContentType.SERIES -> TraktFavoriteType.SHOW+ else -> null+ }+ val traktId = tmdbId?.takeIf { it > 0L }+ if (traktType != null && traktId != null) {+ when (val result = traktFavorites.setFavorited(TraktFavoriteIdentity(traktType, traktId), favorited)) {+ TraktFavoriteActionResult.Success -> Unit+ is TraktFavoriteActionResult.Failure -> if (result.reason != TraktFavoriteFailure.DISCONNECTED &&+ result.reason != TraktFavoriteFailure.INCOGNITO) {+ _userMessages.emit("StreamVault saved the change, but could not update Trakt Favorites. Try again.")+ }+ }+ }}}@@ -387,9 +419,14 @@ fun SearchScreen(var pendingMovie by remember { mutableStateOf<Movie?>(null) }var pendingSeries by remember { mutableStateOf<Series?>(null) }val scope = rememberCoroutineScope()+ val snackbarHostState = remember { SnackbarHostState() }val selectedStateLabel = stringResource(R.string.a11y_selected)val incorrectPinMessage = stringResource(R.string.search_incorrect_pin)+ LaunchedEffect(viewModel) {+ viewModel.userMessages.collect { message -> snackbarHostState.showSnackbar(message) }+ }+// ג”€ג”€ Long-press actions dialog state ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€ג”€var showActionsDialog by remember { mutableStateOf(false) }var actionsChannel by remember { mutableStateOf<Channel?>(null) }@@ -518,7 +555,12 @@ fun SearchScreen(hasCategoryId = actionsCategoryId != null,onDismiss = { showActionsDialog = false },onToggleFavorite = {- viewModel.toggleFavorite(actionsItemId, actionsContentType, actionsIsFavorite)+ viewModel.toggleFavorite(+ actionsItemId,+ actionsContentType,+ actionsIsFavorite,+ actionsMovie?.tmdbId ?: actionsSeries?.tmdbId,+ )actionsIsFavorite = !actionsIsFavorite},onHide = if (actionsCategoryId != null) {@@ -549,6 +591,7 @@ fun SearchScreen(true,false) {+ Box(modifier = Modifier.fillMaxSize()) {LazyColumn(modifier = Modifier.fillMaxSize(),verticalArrangement = Arrangement.spacedBy(18.dp),@@ -817,6 +860,11 @@ fun SearchScreen(}}}+ SnackbarHost(+ hostState = snackbarHostState,+ modifier = Modifier.align(Alignment.BottomCenter).padding(bottom = 16.dp),+ )+ }}}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailScreen.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailScreen.ktindex 59325da0..f1593fa4 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailScreen.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailScreen.kt@@ -64,6 +64,11 @@ import com.streamvault.feature.catalog.presentation.catalogMessageTextimport com.streamvault.feature.catalog.presentation.components.EpisodeRowCardimport com.streamvault.feature.catalog.presentation.components.ExternalRatingsStripimport com.streamvault.feature.catalog.presentation.components.formatVodRatingLabel+import com.streamvault.feature.catalog.presentation.components.TraktWatchlistActionButton+import com.streamvault.feature.catalog.presentation.components.TraktCustomListActionButton+import com.streamvault.feature.catalog.presentation.components.TraktRatingActionButton+import com.streamvault.feature.catalog.presentation.components.TraktRatingDialog+import com.streamvault.feature.catalog.presentation.components.TraktRatingSummaryimport com.streamvault.feature.catalog.presentation.time.formatPositionMsimport com.streamvault.core.ui.device.rememberIsTelevisionDeviceimport com.streamvault.core.ui.image.rememberCrossfadeImageModel@@ -74,6 +79,9 @@ import com.streamvault.domain.model.Episodeimport com.streamvault.domain.model.ExternalRatingsimport com.streamvault.domain.model.Seasonimport com.streamvault.domain.model.Series+import com.streamvault.domain.trakt.TraktCustomListItem+import com.streamvault.domain.trakt.TraktCustomListItemIdentity+import com.streamvault.domain.trakt.TraktCustomListItemTypeimport com.streamvault.domain.model.VodSeriesVariantimport com.streamvault.core.ui.interaction.TvClickableSurfaceimport com.streamvault.core.ui.interaction.TvButton@@ -94,6 +102,7 @@ fun SeriesDetailScreen(val uiState by viewModel.uiState.collectAsStateWithLifecycle()val series = uiState.seriesval context = LocalContext.current+ var ratingDialogOpen by remember(series?.id) { mutableStateOf(false) }LaunchedEffect(viewModel, context, platformHost) {viewModel.uiEvents.collect { event ->@@ -143,6 +152,15 @@ fun SeriesDetailScreen(isCasting = uiState.isCasting,externalRatings = uiState.externalRatings,isLoadingExternalRatings = uiState.isLoadingExternalRatings,+ traktWatchlistConnected = uiState.traktWatchlistConnected,+ traktWatchlistLoaded = uiState.traktWatchlistLoaded,+ traktWatchlisted = uiState.traktWatchlisted,+ traktWatchlistBusy = uiState.traktWatchlistBusy,+ onToggleTraktWatchlist = viewModel::toggleTraktWatchlist,+ traktRatingConnected = uiState.traktWatchlistConnected,+ traktUserRating = uiState.traktUserRating,+ traktRatingBusy = uiState.traktRatingBusy,+ onRateOnTrakt = { ratingDialogOpen = true },onToggleFavorite = viewModel::toggleFavorite,onSelectVariant = viewModel::selectSeriesVariant,onSeasonSelected = viewModel::selectSeason,@@ -162,6 +180,17 @@ fun SeriesDetailScreen(onCastEpisode = viewModel::castEpisode,onBack = onBack)+ if (ratingDialogOpen) {+ TraktRatingDialog(+ currentRating = uiState.traktUserRating,+ busy = uiState.traktRatingBusy,+ onDismiss = { ratingDialogOpen = false },+ onSelect = { rating ->+ ratingDialogOpen = false+ viewModel.rateOnTrakt(rating)+ },+ )+ }}@Composable@@ -173,6 +202,15 @@ private fun SeriesDetailContent(isCasting: Boolean,externalRatings: ExternalRatings,isLoadingExternalRatings: Boolean,+ traktWatchlistConnected: Boolean,+ traktWatchlistLoaded: Boolean,+ traktWatchlisted: Boolean,+ traktWatchlistBusy: Boolean,+ onToggleTraktWatchlist: () -> Unit,+ traktRatingConnected: Boolean,+ traktUserRating: Int?,+ traktRatingBusy: Boolean,+ onRateOnTrakt: () -> Unit,onToggleFavorite: () -> Unit,onSelectVariant: (Long) -> Unit,onSeasonSelected: (Season) -> Unit,@@ -311,6 +349,7 @@ private fun SeriesDetailContent(selectedSeason?.name.orEmpty()))+ TraktRatingSummary(traktUserRating)ExternalRatingsStrip(ratings = externalRatings,isLoading = isLoadingExternalRatings@@ -337,11 +376,43 @@ private fun SeriesDetailContent(onResumeClick = onResumeClick,onCopyUrl = { copyEpisodeUrl(ep) },onCast = onCastResumeEpisode,- onToggleFavorite = onToggleFavorite+ onToggleFavorite = onToggleFavorite,+ hasTraktIdentity = series.tmdbId?.let { it > 0L } == true,+ traktWatchlistConnected = traktWatchlistConnected,+ traktWatchlistLoaded = traktWatchlistLoaded,+ traktWatchlisted = traktWatchlisted,+ traktWatchlistBusy = traktWatchlistBusy,+ onToggleTraktWatchlist = onToggleTraktWatchlist,+ traktRatingConnected = traktRatingConnected,+ traktUserRating = traktUserRating,+ traktRatingBusy = traktRatingBusy,+ onRateOnTrakt = onRateOnTrakt,)}if (resumeEpisode == null) {- SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)+ Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)+ TraktWatchlistActionButton(+ hasIdentity = series.tmdbId?.let { it > 0L } == true,+ connected = traktWatchlistConnected,+ loaded = traktWatchlistLoaded,+ watchlisted = traktWatchlisted,+ busy = traktWatchlistBusy,+ onClick = onToggleTraktWatchlist,+ )+ }+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ TraktRatingActionButton(+ hasIdentity = series.tmdbId?.let { it > 0L } == true,+ connected = traktRatingConnected,+ busy = traktRatingBusy,+ rating = traktUserRating,+ onClick = onRateOnTrakt,+ )+ TraktCustomListActionButton(series.traktShowListItem())+ }+ }}}}@@ -399,6 +470,7 @@ private fun SeriesDetailContent(selectedSeason?.name.orEmpty()))+ TraktRatingSummary(traktUserRating)ExternalRatingsStrip(ratings = externalRatings,isLoading = isLoadingExternalRatings@@ -425,11 +497,43 @@ private fun SeriesDetailContent(onResumeClick = onResumeClick,onCopyUrl = { copyEpisodeUrl(ep) },onCast = onCastResumeEpisode,- onToggleFavorite = onToggleFavorite+ onToggleFavorite = onToggleFavorite,+ hasTraktIdentity = series.tmdbId?.let { it > 0L } == true,+ traktWatchlistConnected = traktWatchlistConnected,+ traktWatchlistLoaded = traktWatchlistLoaded,+ traktWatchlisted = traktWatchlisted,+ traktWatchlistBusy = traktWatchlistBusy,+ onToggleTraktWatchlist = onToggleTraktWatchlist,+ traktRatingConnected = traktRatingConnected,+ traktUserRating = traktUserRating,+ traktRatingBusy = traktRatingBusy,+ onRateOnTrakt = onRateOnTrakt,)}if (resumeEpisode == null) {- SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)+ Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)+ TraktWatchlistActionButton(+ hasIdentity = series.tmdbId?.let { it > 0L } == true,+ connected = traktWatchlistConnected,+ loaded = traktWatchlistLoaded,+ watchlisted = traktWatchlisted,+ busy = traktWatchlistBusy,+ onClick = onToggleTraktWatchlist,+ )+ }+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ TraktRatingActionButton(+ hasIdentity = series.tmdbId?.let { it > 0L } == true,+ connected = traktRatingConnected,+ busy = traktRatingBusy,+ rating = traktUserRating,+ onClick = onRateOnTrakt,+ )+ TraktCustomListActionButton(series.traktShowListItem())+ }+ }}}}@@ -462,17 +566,20 @@ private fun SeriesDetailContent(selectedSeason?.let { season ->item {- Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {- Text(- text = stringResource(R.string.series_episodes, season.episodes.size),- style = MaterialTheme.typography.titleLarge,- color = AppColors.TextPrimary- )- Text(- text = season.name,- style = MaterialTheme.typography.bodyMedium,- color = AppColors.TextTertiary- )+ Row(horizontalArrangement = Arrangement.spacedBy(16.dp), verticalAlignment = Alignment.CenterVertically) {+ Column(modifier = Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(6.dp)) {+ Text(+ text = stringResource(R.string.series_episodes, season.episodes.size),+ style = MaterialTheme.typography.titleLarge,+ color = AppColors.TextPrimary+ )+ Text(+ text = season.name,+ style = MaterialTheme.typography.bodyMedium,+ color = AppColors.TextTertiary+ )+ }+ series?.let { TraktCustomListActionButton(it.traktSeasonListItem(season)) }}}val fallbackCover = series?.let {@@ -481,6 +588,7 @@ private fun SeriesDetailContent(items(visibleEpisodes, key = { it.id }) { episode ->EpisodeItem(episode = episode,+ traktCustomListItem = series?.traktEpisodeListItem(episode),fallbackImageUrl = fallbackCover,onClick = { onEpisodeClick(episode) },onCopyUrl = { copyEpisodeUrl(episode) },@@ -555,60 +663,123 @@ private fun SeriesDetailActions(onResumeClick: (Episode) -> Unit,onCopyUrl: () -> Unit,onCast: () -> Unit,- onToggleFavorite: () -> Unit+ onToggleFavorite: () -> Unit,+ hasTraktIdentity: Boolean,+ traktWatchlistConnected: Boolean,+ traktWatchlistLoaded: Boolean,+ traktWatchlisted: Boolean,+ traktWatchlistBusy: Boolean,+ onToggleTraktWatchlist: () -> Unit,+ traktRatingConnected: Boolean,+ traktUserRating: Int?,+ traktRatingBusy: Boolean,+ onRateOnTrakt: () -> Unit,) {- Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {- TvButton(- onClick = { onResumeClick(resumeEpisode) },- colors = ButtonDefaults.colors(- containerColor = AppColors.Brand,- contentColor = Color.White- )- ) {- Text(- text = if (hasProgress) {- stringResource(- R.string.series_detail_resume,- resumeEpisode.seasonNumber,- resumeEpisode.episodeNumber,- formatPositionMs(resumeEpisode.watchProgress)- )- } else {+ Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {+ TvButton(+ onClick = { onResumeClick(resumeEpisode) },+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Brand,+ contentColor = Color.White+ )+ ) {+ Text(+ text = if (hasProgress) {+ stringResource(+ R.string.series_detail_resume,+ resumeEpisode.seasonNumber,+ resumeEpisode.episodeNumber,+ formatPositionMs(resumeEpisode.watchProgress)+ )+ } else {+ stringResource(+ R.string.series_detail_play_episode,+ resumeEpisode.seasonNumber,+ resumeEpisode.episodeNumber+ )+ }+ )+ }+ TvButton(+ onClick = onCopyUrl,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary+ )+ ) {+ Text(stringResource(R.string.stream_url_copy))+ }+ TvButton(+ onClick = onCast,+ enabled = !isCasting,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary+ )+ ) {+ Text(stringResource(- R.string.series_detail_play_episode,- resumeEpisode.seasonNumber,- resumeEpisode.episodeNumber+ if (isCasting) R.string.cast_launching else R.string.cast_button_label)- }- )- }- TvButton(- onClick = onCopyUrl,- colors = ButtonDefaults.colors(- containerColor = AppColors.SurfaceEmphasis,- contentColor = AppColors.TextPrimary- )- ) {- Text(stringResource(R.string.stream_url_copy))+ )+ }}- TvButton(- onClick = onCast,- enabled = !isCasting,- colors = ButtonDefaults.colors(- containerColor = AppColors.SurfaceEmphasis,- contentColor = AppColors.TextPrimary+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {+ SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)+ TraktWatchlistActionButton(+ hasIdentity = hasTraktIdentity,+ connected = traktWatchlistConnected,+ loaded = traktWatchlistLoaded,+ watchlisted = traktWatchlisted,+ busy = traktWatchlistBusy,+ onClick = onToggleTraktWatchlist,)- ) {- Text(- stringResource(- if (isCasting) R.string.cast_launching else R.string.cast_button_label- )+ TraktRatingActionButton(+ hasIdentity = hasTraktIdentity,+ connected = traktRatingConnected,+ busy = traktRatingBusy,+ rating = traktUserRating,+ onClick = onRateOnTrakt,)+ TraktCustomListActionButton(series.traktShowListItem())}- SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)}}+private fun Series.traktShowListItem(): TraktCustomListItem? {+ val showTmdbId = tmdbId?.takeIf { it > 0L } ?: return null+ return TraktCustomListItem(+ identity = TraktCustomListItemIdentity(TraktCustomListItemType.SHOW, showTmdbId),+ title = name,+ year = releaseDate?.take(4)?.toIntOrNull(),+ )+}++private fun Series.traktSeasonListItem(season: Season): TraktCustomListItem? {+ val showTmdbId = tmdbId?.takeIf { it > 0L } ?: return null+ return TraktCustomListItem(+ identity = TraktCustomListItemIdentity(+ TraktCustomListItemType.SEASON, showTmdbId, seasonNumber = season.seasonNumber,+ ),+ title = "$name · ${season.name}",+ )+}++private fun Series.traktEpisodeListItem(episode: Episode): TraktCustomListItem? {+ val showTmdbId = tmdbId?.takeIf { it > 0L } ?: return null+ if (episode.episodeNumber <= 0) return null+ return TraktCustomListItem(+ identity = TraktCustomListItemIdentity(+ TraktCustomListItemType.EPISODE,+ showTmdbId,+ seasonNumber = episode.seasonNumber,+ episodeNumber = episode.episodeNumber,+ ),+ title = "$name · S${episode.seasonNumber}E${episode.episodeNumber} · ${episode.title}",+ )+}+@Composableprivate fun SeriesDetailFavoriteAction(series: Series,@@ -667,6 +838,7 @@ fun SeasonChip(@Composablefun EpisodeItem(episode: Episode,+ traktCustomListItem: TraktCustomListItem? = null,fallbackImageUrl: String? = null,onClick: () -> Unit,onCopyUrl: () -> Unit,@@ -717,6 +889,7 @@ fun EpisodeItem())}+ TraktCustomListActionButton(traktCustomListItem)}}}diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModel.ktindex 7bbf49aa..acbbf967 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModel.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModel.kt@@ -29,6 +29,21 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.SeriesRepository+import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistActionResult+import com.streamvault.domain.trakt.TraktWatchlistFailure+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistRefreshResult+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktRatings+import com.streamvault.domain.trakt.TraktRatingActionResult+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingTypeimport com.streamvault.domain.util.isPlaybackCompleteimport dagger.hilt.android.lifecycle.HiltViewModelimport kotlinx.coroutines.Job@@ -56,7 +71,10 @@ class SeriesDetailViewModel @Inject constructor(private val streamPreparer: CatalogStreamPreparer,private val downloadManager: DownloadManager,private val downloadStarter: CatalogDownloadStarter,- private val castPort: CatalogCastPort+ private val castPort: CatalogCastPort,+ private val traktWatchlist: TraktWatchlist,+ private val traktFavorites: TraktFavorites,+ private val traktRatings: TraktRatings,) : ViewModel() {private val seriesId: Long = checkNotNull(@@ -80,6 +98,8 @@ class SeriesDetailViewModel @Inject constructor(init {observeCastPlaybackEvents()+ observeTraktWatchlist()+ observeTraktRatings()viewModelScope.launch {providerRepository.getActiveProvider().collect { provider ->providerDetailJob?.cancel()@@ -96,6 +116,67 @@ class SeriesDetailViewModel @Inject constructor(}}+ private fun observeTraktWatchlist() {+ viewModelScope.launch {+ traktWatchlist.state.collect { watchlistState ->+ _uiState.update { current ->+ val identity = current.series?.tmdbId?.takeIf { it > 0L }+ ?.let { TraktWatchlistIdentity(TraktWatchlistType.SHOW, it) }+ current.copy(+ traktWatchlistConnected = watchlistState.connected,+ traktWatchlistLoaded = watchlistState.loaded,+ traktWatchlisted = watchlistState.loaded && identity?.let(watchlistState::contains) == true,+ traktWatchlistBusy = watchlistState.isRefreshing ||+ (identity != null && identity in watchlistState.updating),+ traktWatchlistFailure = watchlistState.failure,+ )+ }+ }+ }+ }++ private fun refreshTraktWatchlist() {+ if (_uiState.value.series?.tmdbId?.let { it > 0L } != true) return+ viewModelScope.launch { traktWatchlist.refresh() }+ }++ private fun observeTraktRatings() {+ viewModelScope.launch {+ traktRatings.state.collect { ratingsState ->+ _uiState.update { current ->+ val identity = current.series?.tmdbId?.takeIf { it > 0L }+ ?.let { TraktRatingIdentity(TraktRatingType.SHOW, it) }+ current.copy(+ traktUserRating = identity?.let(ratingsState::rating),+ traktRatingBusy = ratingsState.refreshing.contains(TraktRatingType.SHOW) ||+ (identity != null && identity in ratingsState.updating),+ )+ }+ }+ }+ }++ private fun refreshTraktRatings() {+ _uiState.value.series?.tmdbId?.takeIf { it > 0L } ?: return+ viewModelScope.launch { traktRatings.refresh(TraktRatingType.SHOW) }+ }++ fun toggleTraktWatchlist() {+ val series = _uiState.value.series ?: return+ val tmdbId = series.tmdbId?.takeIf { it > 0L } ?: return+ val identity = TraktWatchlistIdentity(TraktWatchlistType.SHOW, tmdbId)+ viewModelScope.launch {+ val result = if (!_uiState.value.traktWatchlistLoaded) {+ traktWatchlist.refresh(force = true)+ } else {+ traktWatchlist.setWatchlisted(identity, !_uiState.value.traktWatchlisted)+ }+ if (result is TraktWatchlistRefreshResult.Failure || result is TraktWatchlistActionResult.Failure) {+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktWatchlistFailed))+ }+ }+ }+private suspend fun resolveEffectiveProviderId(fallbackProviderId: Long): Long {return seriesRepository.getSeriesById(seriesId)?.providerId?.takeIf { it > 0L }?: fallbackProviderId@@ -124,6 +205,8 @@ class SeriesDetailViewModel @Inject constructor(error = null)}+ refreshTraktWatchlist()+ refreshTraktRatings()}is Result.Error -> {_uiState.update {@@ -165,6 +248,38 @@ class SeriesDetailViewModel @Inject constructor(favoriteRepository.removeFavorite(series.providerId, series.id, ContentType.SERIES)}_uiState.update { it.copy(series = series.copy(isFavorite = newState)) }+ series.tmdbId?.takeIf { it > 0L }?.let { tmdbId ->+ when (val result = traktFavorites.setFavorited(+ TraktFavoriteIdentity(TraktFavoriteType.SHOW, tmdbId), newState,+ )) {+ TraktFavoriteActionResult.Success -> Unit+ is TraktFavoriteActionResult.Failure -> if (result.reason != TraktFavoriteFailure.DISCONNECTED &&+ result.reason != TraktFavoriteFailure.INCOGNITO) {+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktFavoriteSyncFailed))+ }+ }+ }+ }+ }++ fun rateOnTrakt(rating: Int) {+ val series = _uiState.value.series ?: return+ val tmdbId = series.tmdbId?.takeIf { it > 0L } ?: return+ if (rating !in 1..10 || _uiState.value.traktRatingBusy) return+ viewModelScope.launch {+ _uiState.update { it.copy(traktRatingBusy = true) }+ try {+ when (traktRatings.setRating(TraktRatingIdentity(TraktRatingType.SHOW, tmdbId), rating)) {+ TraktRatingActionResult.Success -> {+ _uiState.update { it.copy(traktUserRating = rating) }+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktRatingSaved))+ }+ is TraktRatingActionResult.Failure ->+ _uiEvents.emit(CatalogUiEvent.ShowMessage(CatalogMessage.TraktRatingFailed))+ }+ } finally {+ _uiState.update { it.copy(traktRatingBusy = false) }+ }}}@@ -375,7 +490,14 @@ data class SeriesDetailUiState(val error: String? = null,val isCasting: Boolean = false,val isLoadingExternalRatings: Boolean = false,- val externalRatings: ExternalRatings = ExternalRatings.unavailable()+ val externalRatings: ExternalRatings = ExternalRatings.unavailable(),+ val traktWatchlistConnected: Boolean = false,+ val traktWatchlistLoaded: Boolean = false,+ val traktWatchlisted: Boolean = false,+ val traktWatchlistBusy: Boolean = false,+ val traktWatchlistFailure: TraktWatchlistFailure? = null,+ val traktUserRating: Int? = null,+ val traktRatingBusy: Boolean = false,)private enum class CastPlaybackReportMode {diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesScreen.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesScreen.ktindex e1228a50..9def4362 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesScreen.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesScreen.kt@@ -376,6 +376,9 @@ private fun SeriesVodContent(else -> 300.dp}var showCategoryPicker by remember { mutableStateOf(false) }+ val traktWatchlistLabel = stringResource(R.string.dashboard_trakt_watchlist_series)+ val traktTrendingLabel = stringResource(R.string.trakt_discovery_trending_series)+ val traktPopularLabel = stringResource(R.string.trakt_discovery_popular_series)val favoriteSeries = uiState.seriesByCategory[uiState.favoriteCategoryName].orEmpty()val continueSeries = uiState.libraryLensRows[SeriesLibraryLens.CONTINUE].orEmpty()val freshSeries = uiState.libraryLensRows[SeriesLibraryLens.FRESH].orEmpty()@@ -464,21 +467,67 @@ private fun SeriesVodContent(?: topRatedSeries.firstOrNull()?.id?: catEntries.firstOrNull()?.value?.firstOrNull()?.id} else null- val categoryOptions = remember(visibleCategoryNames, uiState.categoryCounts, categoryByName, uiState.parentalControlLevel, uiState.unlockedCategoryIds) {- visibleCategoryNames.map { name ->- val matchedCategory = categoryByName[name]- val lockedCategory = matchedCategory?.takeIf(isCategoryLocked)- VodCategoryOption(- name = name,- count = uiState.categoryCounts[name] ?: 0,- onClick = {- if (lockedCategory != null) openProtectedCategory(lockedCategory) else onSelectCategory(name)- },- onLongClick = matchedCategory?.takeIf { lockedCategory == null }?.let { category ->- { onShowCategoryOptions(category.name) }- },- isLocked = lockedCategory != null- )+ val categoryOptions = remember(+ visibleCategoryNames,+ uiState.categoryCounts,+ categoryByName,+ uiState.parentalControlLevel,+ uiState.unlockedCategoryIds,+ uiState.traktWatchlistConnected,+ uiState.traktWatchlistCount,+ uiState.traktTrendingCount,+ uiState.traktPopularCount,+ uiState.showTraktTrendingSeries,+ uiState.showTraktPopularSeries,+ traktTrendingLabel,+ traktPopularLabel,+ traktWatchlistLabel+ ) {+ buildList {+ visibleCategoryNames.forEach { name ->+ val matchedCategory = categoryByName[name]+ val lockedCategory = matchedCategory?.takeIf(isCategoryLocked)+ add(+ VodCategoryOption(+ name = name,+ count = uiState.categoryCounts[name] ?: 0,+ onClick = {+ if (lockedCategory != null) openProtectedCategory(lockedCategory) else onSelectCategory(name)+ },+ onLongClick = matchedCategory?.takeIf { lockedCategory == null }?.let { category ->+ { onShowCategoryOptions(category.name) }+ },+ isLocked = lockedCategory != null+ )+ )+ }+ if (uiState.traktWatchlistConnected) {+ add(+ VodCategoryOption(+ name = traktWatchlistLabel,+ count = uiState.traktWatchlistCount,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktTrendingSeries) {+ add(+ VodCategoryOption(+ name = traktTrendingLabel,+ count = uiState.traktTrendingCount,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktPopularSeries) {+ add(+ VodCategoryOption(+ name = traktPopularLabel,+ count = uiState.traktPopularCount,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY) }+ )+ )+ }}}@@ -570,6 +619,35 @@ private fun SeriesVodContent(onClick = { showCategoryPicker = true }))+ if (uiState.traktWatchlistConnected) {+ add(+ VodActionChip(+ key = VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY,+ label = traktWatchlistLabel,+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktTrendingSeries) {+ add(+ VodActionChip(+ key = VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY,+ label = traktTrendingLabel,+ detail = uiState.traktTrendingCount.takeIf { it > 0 }?.toString(),+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktPopularSeries) {+ add(+ VodActionChip(+ key = VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY,+ label = traktPopularLabel,+ detail = uiState.traktPopularCount.takeIf { it > 0 }?.toString(),+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY) }+ )+ )+ }if (favoriteSeries.isNotEmpty()) {add(VodActionChip(@@ -827,6 +905,9 @@ private fun SeriesVodContent(VodSectionHeader(title = when (uiState.selectedCategory) {uiState.fullLibraryCategoryName -> stringResource(R.string.library_full_browse_title_series)+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> traktWatchlistLabel+ VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY -> traktTrendingLabel+ VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY -> traktPopularLabelelse -> uiState.selectedCategory ?: stringResource(R.string.nav_series)})@@ -928,7 +1009,17 @@ private fun SeriesVodContent() {AppMessageState(title = stringResource(R.string.series_no_found),- subtitle = stringResource(R.string.series_no_found_subtitle)+ subtitle = stringResource(+ when (uiState.selectedCategory) {+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> R.string.trakt_watchlist_series_no_matches+ VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY,+ VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY -> if (+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY && uiState.traktTrendingFailed) ||+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY && uiState.traktPopularFailed)+ ) R.string.trakt_discovery_load_failed else R.string.trakt_discovery_series_no_matches+ else -> R.string.series_no_found_subtitle+ }+ ))}}@@ -1027,6 +1118,9 @@ private fun SeriesVodClassicContent(val allLabel = stringResource(R.string.vod_classic_all)val continueLabel = stringResource(R.string.vod_classic_continue_watching)val recentLabel = stringResource(R.string.vod_classic_recently_added)+ val traktWatchlistLabel = stringResource(R.string.dashboard_trakt_watchlist_series)+ val traktTrendingLabel = stringResource(R.string.trakt_discovery_trending_series)+ val traktPopularLabel = stringResource(R.string.trakt_discovery_popular_series)val categoryByName = remember(uiState.providerCategories, uiState.categories, uiState.favoriteCategoryName) {buildMap<String, Category> {uiState.providerCategories.forEach { put(it.name, it) }@@ -1117,6 +1211,9 @@ private fun SeriesVodClassicContent(}val selectedKey = when {+ uiState.selectedCategory == VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> "trakt_watchlist"+ uiState.selectedCategory == VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY -> "trakt_trending"+ uiState.selectedCategory == VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY -> "trakt_popular"uiState.selectedCategory == uiState.favoriteCategoryName -> "favorites"uiState.selectedCategory == uiState.fullLibraryCategoryName && selectedFilterType == LibraryFilterType.IN_PROGRESS -> "continue"uiState.selectedCategory == uiState.fullLibraryCategoryName && selectedFilterType == LibraryFilterType.RECENTLY_UPDATED -> "recent"@@ -1152,7 +1249,16 @@ private fun SeriesVodClassicContent(recentCount,uiState.libraryCount,uiState.unlockedCategoryIds,- uiState.parentalControlLevel+ uiState.parentalControlLevel,+ uiState.traktWatchlistConnected,+ uiState.traktWatchlistCount,+ uiState.traktTrendingCount,+ uiState.traktPopularCount,+ uiState.showTraktTrendingSeries,+ uiState.showTraktPopularSeries,+ traktTrendingLabel,+ traktPopularLabel,+ traktWatchlistLabel) {buildList {add(@@ -1173,6 +1279,39 @@ private fun SeriesVodClassicContent(onClick = { onSelectCategory(uiState.favoriteCategoryName) }))+ if (uiState.traktWatchlistConnected) {+ add(+ VodClassicCategoryOption(+ key = "trakt_watchlist",+ label = traktWatchlistLabel,+ count = uiState.traktWatchlistCount,+ isSelected = selectedKey == "trakt_watchlist",+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktTrendingSeries) {+ add(+ VodClassicCategoryOption(+ key = "trakt_trending",+ label = traktTrendingLabel,+ count = uiState.traktTrendingCount,+ isSelected = selectedKey == "trakt_trending",+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY) }+ )+ )+ }+ if (uiState.showTraktPopularSeries) {+ add(+ VodClassicCategoryOption(+ key = "trakt_popular",+ label = traktPopularLabel,+ count = uiState.traktPopularCount,+ isSelected = selectedKey == "trakt_popular",+ onClick = { onSelectCategory(VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY) }+ )+ )+ }add(VodClassicCategoryOption(key = "continue",@@ -1232,6 +1371,9 @@ private fun SeriesVodClassicContent(selectedKey == "all" -> allLabelselectedKey == "continue" -> continueLabelselectedKey == "recent" -> recentLabel+ selectedKey == "trakt_watchlist" -> traktWatchlistLabel+ selectedKey == "trakt_trending" -> traktTrendingLabel+ selectedKey == "trakt_popular" -> traktPopularLabelelse -> uiState.selectedCategory ?: allLabel},subtitle = stringResource(@@ -1314,7 +1456,17 @@ private fun SeriesVodClassicContent(item(span = { GridItemSpan(maxLineSpan) }) {AppMessageState(title = stringResource(R.string.series_no_found),- subtitle = stringResource(R.string.vod_classic_empty_category)+ subtitle = stringResource(+ when (uiState.selectedCategory) {+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> R.string.trakt_watchlist_series_no_matches+ VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY,+ VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY -> if (+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY && uiState.traktTrendingFailed) ||+ (uiState.selectedCategory == VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY && uiState.traktPopularFailed)+ ) R.string.trakt_discovery_load_failed else R.string.trakt_discovery_series_no_matches+ else -> R.string.vod_classic_empty_category+ }+ ))}} else {diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.ktindex ee30cfa4..234152cf 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt@@ -23,6 +23,20 @@ import com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.SeriesRepositoryimport com.streamvault.domain.repository.M3uClassificationRepository+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistRefreshResult+import com.streamvault.domain.trakt.TraktWatchlistState+import com.streamvault.domain.trakt.TraktWatchlistType+import com.streamvault.domain.trakt.TraktDiscovery+import com.streamvault.domain.trakt.TraktDiscoveryRefreshResult+import com.streamvault.domain.trakt.TraktDiscoveryStateimport com.streamvault.domain.usecase.ContinueWatchingResultimport com.streamvault.domain.usecase.ContinueWatchingScopeimport com.streamvault.domain.usecase.GetContinueWatching@@ -45,6 +59,8 @@ import com.streamvault.feature.catalog.presentation.vod.setVodSearchQueryimport com.streamvault.feature.catalog.presentation.vod.setVodFavoriteimport com.streamvault.feature.catalog.presentation.vod.updateVodGroupMembershipimport com.streamvault.feature.catalog.presentation.vod.VodBrowseDefaults+import com.streamvault.feature.catalog.presentation.dashboard.orderedWatchlistItems+import com.streamvault.feature.catalog.presentation.dashboard.orderedDiscoveryItemsimport dagger.hilt.android.lifecycle.HiltViewModelimport javax.inject.Injectimport kotlinx.coroutines.ExperimentalCoroutinesApi@@ -84,7 +100,11 @@ class SeriesViewModel @Inject constructor(private val getContinueWatching: GetContinueWatching,private val getCustomCategories: GetCustomCategories,private val parentalControlManager: ParentalControlManager,- private val m3uClassificationRepository: M3uClassificationRepository+ private val m3uClassificationRepository: M3uClassificationRepository,+ private val traktFavorites: TraktFavorites,+ private val traktAccount: TraktAccount,+ private val traktWatchlist: TraktWatchlist,+ private val traktDiscovery: TraktDiscovery,) : ViewModel() {private companion object {const val UNCATEGORIZED = "Uncategorized"@@ -144,6 +164,81 @@ class SeriesViewModel @Inject constructor(}}+ viewModelScope.launch {+ runCatching { traktAccount.load() }+ traktAccount.state+ .map { state -> state.username.takeIf { state.connected } }+ .distinctUntilChanged()+ .collectLatest { username ->+ _uiState.update { it.copy(traktWatchlistConnected = username != null) }+ if (username != null) traktWatchlist.refresh()+ }+ }++ viewModelScope.launch {+ combine(traktAccount.state, traktWatchlist.state) { account, watchlist ->+ val watchlistBelongsToAccount = account.connected &&+ account.username != null &&+ account.username == watchlist.accountUsername+ account.connected to if (watchlistBelongsToAccount) {+ watchlist.items.count { it.type == TraktWatchlistType.SHOW }+ } else {+ 0+ }+ }.collect { (connected, count) ->+ _uiState.update {+ it.copy(traktWatchlistConnected = connected, traktWatchlistCount = count)+ }+ }+ }++ viewModelScope.launch {+ traktDiscovery.state.collect { discovery ->+ _uiState.update {+ it.copy(+ traktTrendingCount = discovery.items(VodBrowseDefaults.TRAKT_TRENDING_SERIES).size,+ traktPopularCount = discovery.items(VodBrowseDefaults.TRAKT_POPULAR_SERIES).size,+ traktTrendingFailed = VodBrowseDefaults.TRAKT_TRENDING_SERIES in discovery.failed,+ traktPopularFailed = VodBrowseDefaults.TRAKT_POPULAR_SERIES in discovery.failed,+ )+ }+ }+ }++ viewModelScope.launch {+ combine(+ preferencesRepository.showTraktTrendingMovies,+ preferencesRepository.showTraktPopularMovies,+ preferencesRepository.showTraktTrendingSeries,+ preferencesRepository.showTraktPopularSeries+ ) { trendingMovies, popularMovies, trendingSeries, popularSeries ->+ listOf(trendingMovies, popularMovies, trendingSeries, popularSeries)+ }.distinctUntilChanged().collect { visibility ->+ val showTrending = visibility[2]+ val showPopular = visibility[3]+ _uiState.update { state ->+ val hideSelectedCategory = when (state.selectedCategory) {+ VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY -> !showTrending+ VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY -> !showPopular+ else -> false+ }+ state.copy(+ showTraktTrendingMovies = visibility[0],+ showTraktPopularMovies = visibility[1],+ showTraktTrendingSeries = showTrending,+ showTraktPopularSeries = showPopular,+ selectedCategory = if (hideSelectedCategory) null else state.selectedCategory,+ selectedCategoryItems = if (hideSelectedCategory) emptyList() else state.selectedCategoryItems,+ selectedCategoryLoadedCount = if (hideSelectedCategory) 0 else state.selectedCategoryLoadedCount,+ selectedCategoryTotalCount = if (hideSelectedCategory) 0 else state.selectedCategoryTotalCount,+ canLoadMoreSelectedCategory = if (hideSelectedCategory) false else state.canLoadMoreSelectedCategory,+ isLoadingSelectedCategory = if (hideSelectedCategory) false else state.isLoadingSelectedCategory,+ isLoadingMoreSelectedCategory = if (hideSelectedCategory) false else state.isLoadingMoreSelectedCategory+ )+ }+ }+ }+viewModelScope.launch {try {providerRepository.getActiveProvider()@@ -370,6 +465,15 @@ class SeriesViewModel @Inject constructor(history = history,hiddenCategoryIds = hiddenCategoryIds)+ }.combine(+ combine(traktAccount.state, traktWatchlist.state) { account, watchlist -> account to watchlist }+ ) { dependencies, traktState ->+ dependencies.copy(+ traktAccountState = traktState.first,+ traktWatchlistState = traktState.second+ )+ }.combine(traktDiscovery.state) { dependencies, discoveryState ->+ dependencies.copy(traktDiscoveryState = discoveryState)}.combine(combine(_uiState.map { it.selectedCategory }.distinctUntilChanged(),@@ -398,7 +502,10 @@ class SeriesViewModel @Inject constructor(history = dependencies.history,customCategories = dependencies.customCategories,providerCategories = dependencies.providerCategories,- hiddenCategoryIds = dependencies.hiddenCategoryIds+ hiddenCategoryIds = dependencies.hiddenCategoryIds,+ traktAccountState = dependencies.traktAccountState,+ traktWatchlistState = dependencies.traktWatchlistState,+ traktDiscoveryState = dependencies.traktDiscoveryState)}}@@ -414,7 +521,8 @@ class SeriesViewModel @Inject constructor(selectedCategoryLoadedCount = snapshot.loadedCount,selectedCategoryTotalCount = snapshot.totalCount,canLoadMoreSelectedCategory = snapshot.canLoadMore,- isLoadingSelectedCategory = initialRemoteRequestInFlight && snapshot.items.isEmpty()+ isLoadingSelectedCategory = snapshot.isLoading ||+ (initialRemoteRequestInFlight && snapshot.items.isEmpty()))}}@@ -575,6 +683,34 @@ class SeriesViewModel @Inject constructor(isLoadingSelectedCategory = isLoadingSelectedCategory)}+ if (categoryName == VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY) {+ viewModelScope.launch {+ when (val result = traktWatchlist.refresh()) {+ is TraktWatchlistRefreshResult.Success -> Unit+ is TraktWatchlistRefreshResult.Failure -> {+ _uiState.update {+ it.copy(+ userMessage = if (result.reason == com.streamvault.domain.trakt.TraktWatchlistFailure.DISCONNECTED) {+ "Connect Trakt in Settings to view your watchlist."+ } else {+ "Could not load the Trakt watchlist. Try again."+ }+ )+ }+ }+ }+ }+ return+ }+ val discoveryCategory = VodBrowseDefaults.traktDiscoveryCategory(categoryName)+ if (discoveryCategory != null) {+ viewModelScope.launch {+ if (traktDiscovery.refresh(discoveryCategory) is TraktDiscoveryRefreshResult.Failure) {+ _uiState.update { it.copy(userMessage = "Could not load Trakt discovery titles. Try again.") }+ }+ }+ return+ }val providerId = activeProviderId ?: returnval categoryId = resolveProviderCategoryId(categoryName) ?: returninitialRemoteRequestInFlight = true@@ -776,6 +912,7 @@ class SeriesViewModel @Inject constructor(viewModelScope.launch {setVodFavorite(series.providerId, series.selectedRawSeriesId(), ContentType.SERIES, true, favoriteRepository)_uiState.update { it.copy(selectedSeriesForDialog = series.copy(isFavorite = true)) }+ syncTraktFavorite(series.tmdbId, true)}}@@ -785,6 +922,20 @@ class SeriesViewModel @Inject constructor(setVodFavorite(series.providerId, rawSeriesId, ContentType.SERIES, false, favoriteRepository)}_uiState.update { it.copy(selectedSeriesForDialog = series.copy(isFavorite = false)) }+ syncTraktFavorite(series.tmdbId, false)+ }+ }++ private suspend fun syncTraktFavorite(tmdbId: Long?, favorited: Boolean) {+ val id = tmdbId?.takeIf { it > 0L } ?: return+ when (val result = traktFavorites.setFavorited(TraktFavoriteIdentity(TraktFavoriteType.SHOW, id), favorited)) {+ TraktFavoriteActionResult.Success -> Unit+ is TraktFavoriteActionResult.Failure -> if (result.reason != TraktFavoriteFailure.DISCONNECTED &&+ result.reason != TraktFavoriteFailure.INCOGNITO) {+ _uiState.update {+ it.copy(userMessage = "StreamVault saved the change, but could not update Trakt Favorites. Try again.")+ }+ }}}@@ -1172,6 +1323,60 @@ class SeriesViewModel @Inject constructor(.toSet()val (selectedItems, totalCount, hasMoreRemote) = when (request.selectedCategory) {+ VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY -> {+ val account = request.traktAccountState+ val watchlist = request.traktWatchlistState+ if (!account.connected || account.username == null ||+ account.username != watchlist.accountUsername || !watchlist.loaded+ ) {+ Triple(emptyList<Series>(), 0, false)+ } else {+ val watchlistTmdbIds = watchlist.items.asSequence()+ .filter { it.type == TraktWatchlistType.SHOW }+ .map { it.tmdbId }+ .toList()+ val catalogItems = seriesRepository.getSeriesByTmdbIds(request.providerId, watchlistTmdbIds)+ .filterNot { series -> series.categoryId in request.hiddenCategoryIds }+ val watchlistSeries = orderedWatchlistItems(+ watchlistItems = watchlist.items,+ type = TraktWatchlistType.SHOW,+ catalogItems = catalogItems,+ tmdbIdOf = Series::tmdbId,+ idOf = Series::id,+ limit = Int.MAX_VALUE+ )+ val filteredItems = applyLocalBrowseToSeries(+ watchlistSeries,+ request.history,+ request.filterType,+ request.sortBy,+ effectiveQuery+ )+ Triple(filteredItems.take(request.loadLimit), filteredItems.size, false)+ }+ }+ VodBrowseDefaults.TRAKT_TRENDING_SERIES_CATEGORY,+ VodBrowseDefaults.TRAKT_POPULAR_SERIES_CATEGORY -> {+ val discoveryCategory = requireNotNull(VodBrowseDefaults.traktDiscoveryCategory(request.selectedCategory))+ val tmdbIds = request.traktDiscoveryState.items(discoveryCategory)+ val catalogItems = seriesRepository.getSeriesByTmdbIds(request.providerId, tmdbIds)+ .filterNot { series -> series.categoryId in request.hiddenCategoryIds }+ val discoverySeries = orderedDiscoveryItems(+ tmdbIds = tmdbIds,+ catalogItems = catalogItems,+ tmdbIdOf = Series::tmdbId,+ idOf = Series::id,+ limit = Int.MAX_VALUE+ )+ val filteredItems = applyLocalBrowseToSeries(+ discoverySeries,+ request.history,+ request.filterType,+ request.sortBy,+ effectiveQuery+ )+ Triple(filteredItems.take(request.loadLimit), filteredItems.size, false)+ }VodBrowseDefaults.FULL_LIBRARY_CATEGORY -> {val result = seriesRepository.browseSeries(@@ -1285,7 +1490,12 @@ class SeriesViewModel @Inject constructor(items = enrichedItems,loadedCount = enrichedItems.size,totalCount = totalCount,- canLoadMore = totalCount > enrichedItems.size || hasMoreRemote+ canLoadMore = totalCount > enrichedItems.size || hasMoreRemote,+ isLoading = request.selectedCategory == VodBrowseDefaults.TRAKT_WATCHLIST_CATEGORY &&+ request.traktWatchlistState.isRefreshing ||+ VodBrowseDefaults.traktDiscoveryCategory(request.selectedCategory)?.let {+ it in request.traktDiscoveryState.refreshing+ } == true)}@@ -1414,7 +1624,10 @@ private data class SeriesCategorySelectionDependencies(val history: List<PlaybackHistory>,val customCategories: List<Category>,val providerCategories: List<Category>,- val hiddenCategoryIds: Set<Long>+ val hiddenCategoryIds: Set<Long>,+ val traktAccountState: TraktAccountState = TraktAccountState(),+ val traktWatchlistState: TraktWatchlistState = TraktWatchlistState(),+ val traktDiscoveryState: TraktDiscoveryState = TraktDiscoveryState())private data class SelectedSeriesCategoryRequest(@@ -1428,7 +1641,10 @@ private data class SelectedSeriesCategoryRequest(val history: List<PlaybackHistory>,val customCategories: List<Category>,val providerCategories: List<Category>,- val hiddenCategoryIds: Set<Long>+ val hiddenCategoryIds: Set<Long>,+ val traktAccountState: TraktAccountState,+ val traktWatchlistState: TraktWatchlistState,+ val traktDiscoveryState: TraktDiscoveryState)private data class SelectedSeriesBrowseSelection(@@ -1443,7 +1659,8 @@ private data class SelectedSeriesCategorySnapshot(val items: List<Series> = emptyList(),val loadedCount: Int = 0,val totalCount: Int = 0,- val canLoadMore: Boolean = false+ val canLoadMore: Boolean = false,+ val isLoading: Boolean = false)data class SeriesUiState(@@ -1451,6 +1668,16 @@ data class SeriesUiState(val categoryNames: List<String> = emptyList(),val categoryCounts: Map<String, Int> = emptyMap(),val libraryCount: Int = 0,+ val traktWatchlistConnected: Boolean = false,+ val traktWatchlistCount: Int = 0,+ val traktTrendingCount: Int = 0,+ val traktPopularCount: Int = 0,+ val traktTrendingFailed: Boolean = false,+ val traktPopularFailed: Boolean = false,+ val showTraktTrendingMovies: Boolean = true,+ val showTraktPopularMovies: Boolean = true,+ val showTraktTrendingSeries: Boolean = true,+ val showTraktPopularSeries: Boolean = true,val favoriteCategoryName: String = "\u2605 Favorites",val fullLibraryCategoryName: String = "__full_library__",val libraryLensRows: Map<SeriesLibraryLens, List<Series>> = emptyMap(),diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodScreenCommon.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodScreenCommon.ktindex f4c0d126..a2030072 100644--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodScreenCommon.kt+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodScreenCommon.kt@@ -6,15 +6,35 @@ import androidx.compose.runtime.LaunchedEffectimport androidx.compose.runtime.rememberCoroutineScopeimport androidx.compose.ui.res.stringResourceimport com.streamvault.feature.catalog.R+import com.streamvault.domain.trakt.TraktDiscoveryCategory+import com.streamvault.domain.trakt.TraktDiscoveryKind+import com.streamvault.domain.trakt.TraktDiscoveryMediaimport com.streamvault.core.ui.components.dialogs.PinDialogimport kotlinx.coroutines.launchobject VodBrowseDefaults {const val FAVORITES_CATEGORY = "\u2605 Favorites"const val FAVORITES_SENTINEL_ID = -999L+ const val TRAKT_WATCHLIST_CATEGORY = "__trakt_watchlist__"+ const val TRAKT_TRENDING_MOVIES_CATEGORY = "__trakt_trending_movies__"+ const val TRAKT_POPULAR_MOVIES_CATEGORY = "__trakt_popular_movies__"+ const val TRAKT_TRENDING_SERIES_CATEGORY = "__trakt_trending_series__"+ const val TRAKT_POPULAR_SERIES_CATEGORY = "__trakt_popular_series__"+ val TRAKT_TRENDING_MOVIES = TraktDiscoveryCategory(TraktDiscoveryMedia.MOVIE, TraktDiscoveryKind.TRENDING)+ val TRAKT_POPULAR_MOVIES = TraktDiscoveryCategory(TraktDiscoveryMedia.MOVIE, TraktDiscoveryKind.POPULAR)+ val TRAKT_TRENDING_SERIES = TraktDiscoveryCategory(TraktDiscoveryMedia.SHOW, TraktDiscoveryKind.TRENDING)+ val TRAKT_POPULAR_SERIES = TraktDiscoveryCategory(TraktDiscoveryMedia.SHOW, TraktDiscoveryKind.POPULAR)const val FULL_LIBRARY_CATEGORY = "__full_library__"const val PREVIEW_ROW_LIMIT = 18const val SELECTED_CATEGORY_PAGE_SIZE = 60++ fun traktDiscoveryCategory(categoryName: String?): TraktDiscoveryCategory? = when (categoryName) {+ TRAKT_TRENDING_MOVIES_CATEGORY -> TRAKT_TRENDING_MOVIES+ TRAKT_POPULAR_MOVIES_CATEGORY -> TRAKT_POPULAR_MOVIES+ TRAKT_TRENDING_SERIES_CATEGORY -> TRAKT_TRENDING_SERIES+ TRAKT_POPULAR_SERIES_CATEGORY -> TRAKT_POPULAR_SERIES+ else -> null+ }}@Composablediff --git a/feature/catalog/src/main/res/values-ar/strings.xml b/feature/catalog/src/main/res/values-ar/strings.xmlindex be162739..4d535ba0 100644--- a/feature/catalog/src/main/res/values-ar/strings.xml+++ b/feature/catalog/src/main/res/values-ar/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">المزامنة مطلوبة</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">إضافة إلى قائمة متابعة Trakt</string>+ <string name="trakt_watchlist_connect">اتصل بـ Trakt من الإعدادات</string>+ <string name="trakt_watchlist_failed">تعذر تحديث قائمة متابعة Trakt. حاول مرة أخرى.</string>+ <string name="trakt_watchlist_load">تحميل قائمة متابعة Trakt</string>+ <string name="trakt_watchlist_remove">إزالة من قائمة متابعة Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">قائمة Trakt للأفلام</string>+ <string name="dashboard_trakt_watchlist_series">قائمة Trakt للمسلسلات</string>+ <string name="trakt_rating_action">قيّم على Trakt</string>+ <string name="trakt_rating_dialog_message">اختر تقييمًا من 1 إلى 10.</string>+ <string name="trakt_rating_current">تقييمك على Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">تم حفظ تقييمك في Trakt.</string>+ <string name="trakt_rating_failed">تعذر حفظ تقييمك في Trakt.</string>+ <string name="trakt_favorite_sync_failed">حفظ StreamVault التغيير، لكن تعذر تحديث مفضلات Trakt. حاول مرة أخرى.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-cs/strings.xml b/feature/catalog/src/main/res/values-cs/strings.xmlindex c579d1f8..2de0fd81 100644--- a/feature/catalog/src/main/res/values-cs/strings.xml+++ b/feature/catalog/src/main/res/values-cs/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synchronizace potřebná</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Přidat do seznamu ke zhlédnutí Trakt</string>+ <string name="trakt_watchlist_connect">Připojte Trakt v Nastavení</string>+ <string name="trakt_watchlist_failed">Seznam ke zhlédnutí Trakt se nepodařilo aktualizovat. Zkuste to znovu.</string>+ <string name="trakt_watchlist_load">Načíst seznam ke zhlédnutí Trakt</string>+ <string name="trakt_watchlist_remove">Odebrat ze seznamu ke zhlédnutí Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Ohodnotit na Traktu</string>+ <string name="trakt_rating_dialog_message">Vyberte hodnocení od 1 do 10.</string>+ <string name="trakt_rating_current">Vaše hodnocení na Traktu: %1$d/10</string>+ <string name="trakt_rating_saved">Hodnocení bylo uloženo do Traktu.</string>+ <string name="trakt_rating_failed">Hodnocení se nepodařilo uložit do Traktu.</string>+ <string name="trakt_favorite_sync_failed">StreamVault změnu uložil, ale nepodařilo se aktualizovat Oblíbené na Traktu. Zkuste to znovu.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-da/strings.xml b/feature/catalog/src/main/res/values-da/strings.xmlindex f46fb8b3..e7838e9d 100644--- a/feature/catalog/src/main/res/values-da/strings.xml+++ b/feature/catalog/src/main/res/values-da/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synkronisering nødvendig</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Føj til Trakt-overvågningslisten</string>+ <string name="trakt_watchlist_connect">Opret forbindelse til Trakt i Indstillinger</string>+ <string name="trakt_watchlist_failed">Trakt-overvågningslisten kunne ikke opdateres. Prøv igen.</string>+ <string name="trakt_watchlist_load">Indlæs Trakt-overvågningslisten</string>+ <string name="trakt_watchlist_remove">Fjern fra Trakt-overvågningslisten</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Bedøm på Trakt</string>+ <string name="trakt_rating_dialog_message">Vælg en bedømmelse fra 1 til 10.</string>+ <string name="trakt_rating_current">Din Trakt-bedømmelse: %1$d/10</string>+ <string name="trakt_rating_saved">Din bedømmelse blev gemt på Trakt.</string>+ <string name="trakt_rating_failed">Kunne ikke gemme din bedømmelse på Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault gemte ændringen, men kunne ikke opdatere Trakt-favoritter. Prøv igen.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-de/strings.xml b/feature/catalog/src/main/res/values-de/strings.xmlindex 62c0d018..f27206b5 100644--- a/feature/catalog/src/main/res/values-de/strings.xml+++ b/feature/catalog/src/main/res/values-de/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synchronisierung erforderlich</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Zur Trakt-Merkliste hinzufügen</string>+ <string name="trakt_watchlist_connect">Trakt in den Einstellungen verbinden</string>+ <string name="trakt_watchlist_failed">Die Trakt-Merkliste konnte nicht aktualisiert werden. Bitte versuche es erneut.</string>+ <string name="trakt_watchlist_load">Trakt-Merkliste laden</string>+ <string name="trakt_watchlist_remove">Von der Trakt-Merkliste entfernen</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Auf Trakt bewerten</string>+ <string name="trakt_rating_dialog_message">Wähle eine Bewertung von 1 bis 10.</string>+ <string name="trakt_rating_current">Deine Trakt-Bewertung: %1$d/10</string>+ <string name="trakt_rating_saved">Deine Bewertung wurde auf Trakt gespeichert.</string>+ <string name="trakt_rating_failed">Deine Bewertung konnte nicht auf Trakt gespeichert werden.</string>+ <string name="trakt_favorite_sync_failed">StreamVault hat die Änderung gespeichert, konnte aber die Trakt-Favoriten nicht aktualisieren. Versuche es erneut.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-el/strings.xml b/feature/catalog/src/main/res/values-el/strings.xmlindex 5c211e97..85f0553d 100644--- a/feature/catalog/src/main/res/values-el/strings.xml+++ b/feature/catalog/src/main/res/values-el/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Απαιτείται συγχρονισμός</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Προσθήκη στη λίστα παρακολούθησης Trakt</string>+ <string name="trakt_watchlist_connect">Συνδέστε το Trakt από τις Ρυθμίσεις</string>+ <string name="trakt_watchlist_failed">Δεν ήταν δυνατή η ενημέρωση της λίστας Trakt. Δοκιμάστε ξανά.</string>+ <string name="trakt_watchlist_load">Φόρτωση λίστας Trakt</string>+ <string name="trakt_watchlist_remove">Αφαίρεση από τη λίστα Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Βαθμολόγηση στο Trakt</string>+ <string name="trakt_rating_dialog_message">Επιλέξτε βαθμολογία από 1 έως 10.</string>+ <string name="trakt_rating_current">Η βαθμολογία σας στο Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">Η βαθμολογία σας αποθηκεύτηκε στο Trakt.</string>+ <string name="trakt_rating_failed">Δεν ήταν δυνατή η αποθήκευση της βαθμολογίας σας στο Trakt.</string>+ <string name="trakt_favorite_sync_failed">Το StreamVault αποθήκευσε την αλλαγή, αλλά δεν μπόρεσε να ενημερώσει τα αγαπημένα του Trakt. Δοκιμάστε ξανά.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-es/strings.xml b/feature/catalog/src/main/res/values-es/strings.xmlindex 83bcc171..b19fd0c7 100644--- a/feature/catalog/src/main/res/values-es/strings.xml+++ b/feature/catalog/src/main/res/values-es/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Sincronización necesaria</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Añadir a la lista de seguimiento de Trakt</string>+ <string name="trakt_watchlist_connect">Conecta Trakt en Ajustes</string>+ <string name="trakt_watchlist_failed">No se pudo actualizar la lista de Trakt. Inténtalo de nuevo.</string>+ <string name="trakt_watchlist_load">Cargar la lista de seguimiento de Trakt</string>+ <string name="trakt_watchlist_remove">Quitar de la lista de seguimiento de Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Calificar en Trakt</string>+ <string name="trakt_rating_dialog_message">Elige una puntuación del 1 al 10.</string>+ <string name="trakt_rating_current">Tu puntuación en Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">Tu puntuación se guardó en Trakt.</string>+ <string name="trakt_rating_failed">No se pudo guardar tu puntuación en Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault guardó el cambio, pero no pudo actualizar tus favoritos de Trakt. Inténtalo de nuevo.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-fi/strings.xml b/feature/catalog/src/main/res/values-fi/strings.xmlindex 3b4f3b96..039ee885 100644--- a/feature/catalog/src/main/res/values-fi/strings.xml+++ b/feature/catalog/src/main/res/values-fi/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synkronointi tarvitaan</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Lisää Trakt-katselulistalle</string>+ <string name="trakt_watchlist_connect">Yhdistä Trakt Asetuksissa</string>+ <string name="trakt_watchlist_failed">Trakt-katselulistan päivitys epäonnistui. Yritä uudelleen.</string>+ <string name="trakt_watchlist_load">Lataa Trakt-katselulista</string>+ <string name="trakt_watchlist_remove">Poista Trakt-katselulistalta</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Arvioi Traktissa</string>+ <string name="trakt_rating_dialog_message">Valitse arvosana 1–10.</string>+ <string name="trakt_rating_current">Trakt-arvosanasi: %1$d/10</string>+ <string name="trakt_rating_saved">Arvosanasi tallennettiin Traktiin.</string>+ <string name="trakt_rating_failed">Arvosanan tallentaminen Traktiin epäonnistui.</string>+ <string name="trakt_favorite_sync_failed">StreamVault tallensi muutoksen, mutta Trakt-suosikkeja ei voitu päivittää. Yritä uudelleen.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-fr/strings.xml b/feature/catalog/src/main/res/values-fr/strings.xmlindex a6fbb8b9..63ef021b 100644--- a/feature/catalog/src/main/res/values-fr/strings.xml+++ b/feature/catalog/src/main/res/values-fr/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synchronisation requise</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Ajouter à la liste de suivi Trakt</string>+ <string name="trakt_watchlist_connect">Connectez Trakt dans les paramètres</string>+ <string name="trakt_watchlist_failed">Impossible de mettre à jour la liste Trakt. Réessayez.</string>+ <string name="trakt_watchlist_load">Charger la liste de suivi Trakt</string>+ <string name="trakt_watchlist_remove">Retirer de la liste de suivi Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Noter sur Trakt</string>+ <string name="trakt_rating_dialog_message">Choisissez une note de 1 à 10.</string>+ <string name="trakt_rating_current">Votre note Trakt : %1$d/10</string>+ <string name="trakt_rating_saved">Votre note a été enregistrée sur Trakt.</string>+ <string name="trakt_rating_failed">Impossible d’enregistrer votre note sur Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault a enregistré la modification, mais n’a pas pu mettre à jour vos favoris Trakt. Réessayez.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-hu/strings.xml b/feature/catalog/src/main/res/values-hu/strings.xmlindex 548e57e5..ee5e1246 100644--- a/feature/catalog/src/main/res/values-hu/strings.xml+++ b/feature/catalog/src/main/res/values-hu/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Szinkronizálás szükséges</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Hozzáadás a Trakt megtekintendő listájához</string>+ <string name="trakt_watchlist_connect">Csatlakoztasd a Traktot a Beállításokban</string>+ <string name="trakt_watchlist_failed">Nem sikerült frissíteni a Trakt listáját. Próbáld újra.</string>+ <string name="trakt_watchlist_load">Trakt lista betöltése</string>+ <string name="trakt_watchlist_remove">Eltávolítás a Trakt listájáról</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Értékelés Trakton</string>+ <string name="trakt_rating_dialog_message">Válassz értékelést 1-től 10-ig.</string>+ <string name="trakt_rating_current">Trakt-értékelésed: %1$d/10</string>+ <string name="trakt_rating_saved">Az értékelésed mentve a Traktra.</string>+ <string name="trakt_rating_failed">Nem sikerült menteni az értékelésedet a Traktra.</string>+ <string name="trakt_favorite_sync_failed">A StreamVault mentette a módosítást, de nem sikerült frissítenie a Trakt kedvenceket. Próbáld újra.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-in/strings.xml b/feature/catalog/src/main/res/values-in/strings.xmlindex d2ff6c69..4faed4fa 100644--- a/feature/catalog/src/main/res/values-in/strings.xml+++ b/feature/catalog/src/main/res/values-in/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Sinkronisasi diperlukan</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Tambahkan ke daftar tontonan Trakt</string>+ <string name="trakt_watchlist_connect">Hubungkan Trakt di Setelan</string>+ <string name="trakt_watchlist_failed">Tidak dapat memperbarui daftar tontonan Trakt. Coba lagi.</string>+ <string name="trakt_watchlist_load">Muat daftar tontonan Trakt</string>+ <string name="trakt_watchlist_remove">Hapus dari daftar tontonan Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Beri nilai di Trakt</string>+ <string name="trakt_rating_dialog_message">Pilih nilai dari 1 sampai 10.</string>+ <string name="trakt_rating_current">Nilai Trakt Anda: %1$d/10</string>+ <string name="trakt_rating_saved">Nilai Anda tersimpan di Trakt.</string>+ <string name="trakt_rating_failed">Nilai Anda tidak dapat disimpan di Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault menyimpan perubahan, tetapi tidak dapat memperbarui Favorit Trakt. Coba lagi.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-it/strings.xml b/feature/catalog/src/main/res/values-it/strings.xmlindex 9d39f339..b3b671f7 100644--- a/feature/catalog/src/main/res/values-it/strings.xml+++ b/feature/catalog/src/main/res/values-it/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Sincronizzazione necessaria</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>+ <string name="trakt_watchlist_add">Aggiungi alla lista dei contenuti da guardare di Trakt</string>+ <string name="trakt_watchlist_connect">Collega Trakt nelle Impostazioni</string>+ <string name="trakt_watchlist_failed">Impossibile aggiornare la lista Trakt. Riprova.</string>+ <string name="trakt_watchlist_load">Carica la lista di Trakt</string>+ <string name="trakt_watchlist_remove">Rimuovi dalla lista di Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Film nella watchlist Trakt</string>+ <string name="dashboard_trakt_watchlist_series">Serie nella watchlist Trakt</string>+ <string name="trakt_rating_action">Valuta su Trakt</string>+ <string name="trakt_rating_dialog_message">Scegli una valutazione da 1 a 10.</string>+ <string name="trakt_rating_current">La tua valutazione Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">La tua valutazione è stata salvata su Trakt.</string>+ <string name="trakt_rating_failed">Impossibile salvare la valutazione su Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault ha salvato la modifica, ma non è riuscito ad aggiornare i Preferiti di Trakt. Riprova.</string></resources>diff --git a/feature/catalog/src/main/res/values-iw/strings.xml b/feature/catalog/src/main/res/values-iw/strings.xmlindex 4127c140..e68f10ce 100644--- a/feature/catalog/src/main/res/values-iw/strings.xml+++ b/feature/catalog/src/main/res/values-iw/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">נדרש סנכרון</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">הוספה לרשימת הצפייה של Trakt</string>+ <string name="trakt_watchlist_connect">יש להתחבר ל‑Trakt דרך ההגדרות</string>+ <string name="trakt_watchlist_failed">לא ניתן לעדכן את רשימת Trakt. נסו שוב.</string>+ <string name="trakt_watchlist_load">טעינת רשימת הצפייה של Trakt</string>+ <string name="trakt_watchlist_remove">הסרה מרשימת הצפייה של Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">דרגו ב‑Trakt</string>+ <string name="trakt_rating_dialog_message">בחרו דירוג בין 1 ל‑10.</string>+ <string name="trakt_rating_current">הדירוג שלך ב‑Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">הדירוג נשמר ב‑Trakt.</string>+ <string name="trakt_rating_failed">לא ניתן לשמור את הדירוג ב‑Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault שמר את השינוי, אך לא הצליח לעדכן את המועדפים ב‑Trakt. נסו שוב.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-ja/strings.xml b/feature/catalog/src/main/res/values-ja/strings.xmlindex 95399aa5..beb0528a 100644--- a/feature/catalog/src/main/res/values-ja/strings.xml+++ b/feature/catalog/src/main/res/values-ja/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">同期が必要</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Trakt のウォッチリストに追加</string>+ <string name="trakt_watchlist_connect">設定で Trakt に接続</string>+ <string name="trakt_watchlist_failed">Trakt のウォッチリストを更新できませんでした。もう一度お試しください。</string>+ <string name="trakt_watchlist_load">Trakt のウォッチリストを読み込む</string>+ <string name="trakt_watchlist_remove">Trakt のウォッチリストから削除</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Traktで評価</string>+ <string name="trakt_rating_dialog_message">1~10の評価を選択してください。</string>+ <string name="trakt_rating_current">Traktでの評価: %1$d/10</string>+ <string name="trakt_rating_saved">評価をTraktに保存しました。</string>+ <string name="trakt_rating_failed">評価をTraktに保存できませんでした。</string>+ <string name="trakt_favorite_sync_failed">StreamVaultで変更を保存しましたが、Traktのお気に入りを更新できませんでした。もう一度お試しください。</string>+</resources>diff --git a/feature/catalog/src/main/res/values-ko/strings.xml b/feature/catalog/src/main/res/values-ko/strings.xmlindex dfbce734..0644204f 100644--- a/feature/catalog/src/main/res/values-ko/strings.xml+++ b/feature/catalog/src/main/res/values-ko/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">동기화 필요</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Trakt 관심 목록에 추가</string>+ <string name="trakt_watchlist_connect">설정에서 Trakt 연결</string>+ <string name="trakt_watchlist_failed">Trakt 관심 목록을 업데이트할 수 없습니다. 다시 시도하세요.</string>+ <string name="trakt_watchlist_load">Trakt 관심 목록 불러오기</string>+ <string name="trakt_watchlist_remove">Trakt 관심 목록에서 삭제</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Trakt에서 평가</string>+ <string name="trakt_rating_dialog_message">1에서 10까지 평가를 선택하세요.</string>+ <string name="trakt_rating_current">내 Trakt 평점: %1$d/10</string>+ <string name="trakt_rating_saved">Trakt에 평점을 저장했습니다.</string>+ <string name="trakt_rating_failed">Trakt에 평점을 저장하지 못했습니다.</string>+ <string name="trakt_favorite_sync_failed">StreamVault에서 변경 사항을 저장했지만 Trakt 즐겨찾기를 업데이트하지 못했습니다. 다시 시도하세요.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-nb/strings.xml b/feature/catalog/src/main/res/values-nb/strings.xmlindex 9c6ed22f..60eac90f 100644--- a/feature/catalog/src/main/res/values-nb/strings.xml+++ b/feature/catalog/src/main/res/values-nb/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synkronisering nødvendig</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Legg til på Trakt-listen</string>+ <string name="trakt_watchlist_connect">Koble til Trakt i Innstillinger</string>+ <string name="trakt_watchlist_failed">Kunne ikke oppdatere Trakt-listen. Prøv igjen.</string>+ <string name="trakt_watchlist_load">Last inn Trakt-listen</string>+ <string name="trakt_watchlist_remove">Fjern fra Trakt-listen</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Vurder på Trakt</string>+ <string name="trakt_rating_dialog_message">Velg en vurdering fra 1 til 10.</string>+ <string name="trakt_rating_current">Din Trakt-vurdering: %1$d/10</string>+ <string name="trakt_rating_saved">Vurderingen ble lagret på Trakt.</string>+ <string name="trakt_rating_failed">Kunne ikke lagre vurderingen på Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault lagret endringen, men kunne ikke oppdatere Trakt-favorittene. Prøv igjen.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-nl/strings.xml b/feature/catalog/src/main/res/values-nl/strings.xmlindex 99e63413..b08934c5 100644--- a/feature/catalog/src/main/res/values-nl/strings.xml+++ b/feature/catalog/src/main/res/values-nl/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synchronisatie vereist</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Toevoegen aan Trakt-volglijst</string>+ <string name="trakt_watchlist_connect">Verbind Trakt via Instellingen</string>+ <string name="trakt_watchlist_failed">De Trakt-volglijst kon niet worden bijgewerkt. Probeer het opnieuw.</string>+ <string name="trakt_watchlist_load">Trakt-volglijst laden</string>+ <string name="trakt_watchlist_remove">Verwijderen van Trakt-volglijst</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Beoordeel op Trakt</string>+ <string name="trakt_rating_dialog_message">Kies een beoordeling van 1 tot 10.</string>+ <string name="trakt_rating_current">Je Trakt-beoordeling: %1$d/10</string>+ <string name="trakt_rating_saved">Je beoordeling is opgeslagen op Trakt.</string>+ <string name="trakt_rating_failed">Je beoordeling kon niet op Trakt worden opgeslagen.</string>+ <string name="trakt_favorite_sync_failed">StreamVault heeft de wijziging opgeslagen, maar kon de Trakt-favorieten niet bijwerken. Probeer het opnieuw.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-pl/strings.xml b/feature/catalog/src/main/res/values-pl/strings.xmlindex 72bbc279..42e97711 100644--- a/feature/catalog/src/main/res/values-pl/strings.xml+++ b/feature/catalog/src/main/res/values-pl/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Wymagana synchronizacja</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Dodaj do listy do obejrzenia Trakt</string>+ <string name="trakt_watchlist_connect">Połącz Trakt w Ustawieniach</string>+ <string name="trakt_watchlist_failed">Nie udało się zaktualizować listy Trakt. Spróbuj ponownie.</string>+ <string name="trakt_watchlist_load">Wczytaj listę Trakt</string>+ <string name="trakt_watchlist_remove">Usuń z listy Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Oceń w Trakt</string>+ <string name="trakt_rating_dialog_message">Wybierz ocenę od 1 do 10.</string>+ <string name="trakt_rating_current">Twoja ocena w Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">Twoja ocena została zapisana w Trakt.</string>+ <string name="trakt_rating_failed">Nie udało się zapisać oceny w Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault zapisał zmianę, ale nie udało się zaktualizować ulubionych Trakt. Spróbuj ponownie.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-pt/strings.xml b/feature/catalog/src/main/res/values-pt/strings.xmlindex cd7f0f1f..a0afeb57 100644--- a/feature/catalog/src/main/res/values-pt/strings.xml+++ b/feature/catalog/src/main/res/values-pt/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Sincronização necessária</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Adicionar à lista para assistir do Trakt</string>+ <string name="trakt_watchlist_connect">Conecte o Trakt nas Configurações</string>+ <string name="trakt_watchlist_failed">Não foi possível atualizar a lista do Trakt. Tente novamente.</string>+ <string name="trakt_watchlist_load">Carregar lista do Trakt</string>+ <string name="trakt_watchlist_remove">Remover da lista do Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Avaliar no Trakt</string>+ <string name="trakt_rating_dialog_message">Escolha uma avaliação de 1 a 10.</string>+ <string name="trakt_rating_current">Sua avaliação no Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">Sua avaliação foi salva no Trakt.</string>+ <string name="trakt_rating_failed">Não foi possível salvar sua avaliação no Trakt.</string>+ <string name="trakt_favorite_sync_failed">O StreamVault salvou a alteração, mas não conseguiu atualizar os Favoritos do Trakt. Tente novamente.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-ro/strings.xml b/feature/catalog/src/main/res/values-ro/strings.xmlindex b7e8f849..c884c41e 100644--- a/feature/catalog/src/main/res/values-ro/strings.xml+++ b/feature/catalog/src/main/res/values-ro/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Sincronizare necesară</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Adaugă în lista de vizionare Trakt</string>+ <string name="trakt_watchlist_connect">Conectează Trakt din Setări</string>+ <string name="trakt_watchlist_failed">Lista Trakt nu a putut fi actualizată. Încearcă din nou.</string>+ <string name="trakt_watchlist_load">Încarcă lista Trakt</string>+ <string name="trakt_watchlist_remove">Elimină din lista Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Evaluează pe Trakt</string>+ <string name="trakt_rating_dialog_message">Alege o notă de la 1 la 10.</string>+ <string name="trakt_rating_current">Nota ta pe Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">Nota ta a fost salvată pe Trakt.</string>+ <string name="trakt_rating_failed">Nu s-a putut salva nota pe Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault a salvat modificarea, dar nu a putut actualiza Favoritele Trakt. Încearcă din nou.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-ru/strings.xml b/feature/catalog/src/main/res/values-ru/strings.xmlindex f4c4c224..716a2224 100644--- a/feature/catalog/src/main/res/values-ru/strings.xml+++ b/feature/catalog/src/main/res/values-ru/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Требуется синхронизация</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Добавить в список просмотра Trakt</string>+ <string name="trakt_watchlist_connect">Подключите Trakt в настройках</string>+ <string name="trakt_watchlist_failed">Не удалось обновить список Trakt. Попробуйте ещё раз.</string>+ <string name="trakt_watchlist_load">Загрузить список Trakt</string>+ <string name="trakt_watchlist_remove">Удалить из списка Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Оценить в Trakt</string>+ <string name="trakt_rating_dialog_message">Выберите оценку от 1 до 10.</string>+ <string name="trakt_rating_current">Ваша оценка в Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">Оценка сохранена в Trakt.</string>+ <string name="trakt_rating_failed">Не удалось сохранить оценку в Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault сохранил изменение, но не смог обновить избранное Trakt. Попробуйте снова.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-sv/strings.xml b/feature/catalog/src/main/res/values-sv/strings.xmlindex 6807a88a..43cb8e60 100644--- a/feature/catalog/src/main/res/values-sv/strings.xml+++ b/feature/catalog/src/main/res/values-sv/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Synkronisering krävs</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Lägg till i Trakts bevakningslista</string>+ <string name="trakt_watchlist_connect">Anslut Trakt i Inställningar</string>+ <string name="trakt_watchlist_failed">Det gick inte att uppdatera Trakts bevakningslista. Försök igen.</string>+ <string name="trakt_watchlist_load">Läs in Trakts bevakningslista</string>+ <string name="trakt_watchlist_remove">Ta bort från Trakts bevakningslista</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Betygsätt på Trakt</string>+ <string name="trakt_rating_dialog_message">Välj ett betyg från 1 till 10.</string>+ <string name="trakt_rating_current">Ditt Trakt-betyg: %1$d/10</string>+ <string name="trakt_rating_saved">Ditt betyg har sparats på Trakt.</string>+ <string name="trakt_rating_failed">Det gick inte att spara ditt betyg på Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault sparade ändringen men kunde inte uppdatera dina Trakt-favoriter. Försök igen.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-tr/strings.xml b/feature/catalog/src/main/res/values-tr/strings.xmlindex 2fcdce9b..fd343f29 100644--- a/feature/catalog/src/main/res/values-tr/strings.xml+++ b/feature/catalog/src/main/res/values-tr/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Senkronizasyon gerekli</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Trakt izleme listesine ekle</string>+ <string name="trakt_watchlist_connect">Trakt\'ı Ayarlar\'dan bağla</string>+ <string name="trakt_watchlist_failed">Trakt izleme listesi güncellenemedi. Tekrar deneyin.</string>+ <string name="trakt_watchlist_load">Trakt izleme listesini yükle</string>+ <string name="trakt_watchlist_remove">Trakt izleme listesinden kaldır</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Trakt\'ta puanla</string>+ <string name="trakt_rating_dialog_message">1 ile 10 arasında bir puan seçin.</string>+ <string name="trakt_rating_current">Trakt puanınız: %1$d/10</string>+ <string name="trakt_rating_saved">Puanınız Trakt üzerine kaydedildi.</string>+ <string name="trakt_rating_failed">Puanınız Trakt üzerine kaydedilemedi.</string>+ <string name="trakt_favorite_sync_failed">StreamVault değişikliği kaydetti ancak Trakt Favorilerini güncelleyemedi. Yeniden deneyin.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-uk/strings.xml b/feature/catalog/src/main/res/values-uk/strings.xmlindex 804287a1..0e425456 100644--- a/feature/catalog/src/main/res/values-uk/strings.xml+++ b/feature/catalog/src/main/res/values-uk/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Необхідна синхронізація</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Додати до списку перегляду Trakt</string>+ <string name="trakt_watchlist_connect">Підключіть Trakt у налаштуваннях</string>+ <string name="trakt_watchlist_failed">Не вдалося оновити список Trakt. Спробуйте ще раз.</string>+ <string name="trakt_watchlist_load">Завантажити список Trakt</string>+ <string name="trakt_watchlist_remove">Видалити зі списку Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Оцінити в Trakt</string>+ <string name="trakt_rating_dialog_message">Виберіть оцінку від 1 до 10.</string>+ <string name="trakt_rating_current">Ваша оцінка в Trakt: %1$d/10</string>+ <string name="trakt_rating_saved">Оцінку збережено в Trakt.</string>+ <string name="trakt_rating_failed">Не вдалося зберегти оцінку в Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault зберіг зміни, але не зміг оновити обране Trakt. Спробуйте ще раз.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-vi/strings.xml b/feature/catalog/src/main/res/values-vi/strings.xmlindex d9be676d..4ae99a85 100644--- a/feature/catalog/src/main/res/values-vi/strings.xml+++ b/feature/catalog/src/main/res/values-vi/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">Cần đồng bộ</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">Thêm vào danh sách xem sau của Trakt</string>+ <string name="trakt_watchlist_connect">Kết nối Trakt trong Cài đặt</string>+ <string name="trakt_watchlist_failed">Không thể cập nhật danh sách Trakt. Hãy thử lại.</string>+ <string name="trakt_watchlist_load">Tải danh sách Trakt</string>+ <string name="trakt_watchlist_remove">Xóa khỏi danh sách Trakt</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">Đánh giá trên Trakt</string>+ <string name="trakt_rating_dialog_message">Chọn điểm từ 1 đến 10.</string>+ <string name="trakt_rating_current">Điểm Trakt của bạn: %1$d/10</string>+ <string name="trakt_rating_saved">Đã lưu điểm của bạn vào Trakt.</string>+ <string name="trakt_rating_failed">Không thể lưu điểm của bạn vào Trakt.</string>+ <string name="trakt_favorite_sync_failed">StreamVault đã lưu thay đổi nhưng không thể cập nhật Mục yêu thích Trakt. Hãy thử lại.</string>+</resources>diff --git a/feature/catalog/src/main/res/values-zh/strings.xml b/feature/catalog/src/main/res/values-zh/strings.xmlindex f502277e..ac70bd26 100644--- a/feature/catalog/src/main/res/values-zh/strings.xml+++ b/feature/catalog/src/main/res/values-zh/strings.xml@@ -351,4 +351,17 @@<string name="vod_sync_needed_title">需要同步</string><string name="vod_unavailable_subtitle" translatable="false">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title" translatable="false">VOD is unavailable</string>-</resources>\ No newline at end of file+ <string name="trakt_watchlist_add">添加到 Trakt 稍后观看列表</string>+ <string name="trakt_watchlist_connect">在设置中连接 Trakt</string>+ <string name="trakt_watchlist_failed">无法更新 Trakt 列表,请重试。</string>+ <string name="trakt_watchlist_load">加载 Trakt 稍后观看列表</string>+ <string name="trakt_watchlist_remove">从 Trakt 列表中移除</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_rating_action">在 Trakt 上评分</string>+ <string name="trakt_rating_dialog_message">选择 1 到 10 之间的评分。</string>+ <string name="trakt_rating_current">你的 Trakt 评分:%1$d/10</string>+ <string name="trakt_rating_saved">评分已保存到 Trakt。</string>+ <string name="trakt_rating_failed">无法将评分保存到 Trakt。</string>+ <string name="trakt_favorite_sync_failed">StreamVault 已保存更改,但无法更新 Trakt 收藏夹。请重试。</string>+</resources>diff --git a/feature/catalog/src/main/res/values/strings.xml b/feature/catalog/src/main/res/values/strings.xmlindex 32a54135..f2c9968c 100644--- a/feature/catalog/src/main/res/values/strings.xml+++ b/feature/catalog/src/main/res/values/strings.xml@@ -65,6 +65,17 @@<string name="dashboard_favorite_channels">Favorite Channels</string><string name="dashboard_favorite_movies">Favorite Movies</string><string name="dashboard_favorite_series">Favorite Series</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string>+ <string name="trakt_watchlist_movies_no_matches">No movies from your Trakt watchlist match this provider or the current filters.</string>+ <string name="trakt_watchlist_series_no_matches">No series from your Trakt watchlist match this provider or the current filters.</string>+ <string name="trakt_discovery_trending_movies">Trending on Trakt</string>+ <string name="trakt_discovery_popular_movies">Popular on Trakt</string>+ <string name="trakt_discovery_trending_series">Trending on Trakt</string>+ <string name="trakt_discovery_popular_series">Popular on Trakt</string>+ <string name="trakt_discovery_movies_no_matches">No trending or popular Trakt movies match this provider or the current filters.</string>+ <string name="trakt_discovery_series_no_matches">No trending or popular Trakt shows match this provider or the current filters.</string>+ <string name="trakt_discovery_load_failed">Could not load Trakt discovery titles. Try again.</string><string name="dashboard_fresh_movie_pick">Fresh movie pick</string><string name="dashboard_jump_back_live">Jump back into live TV</string><string name="dashboard_library_ready">Your IPTV library is ready</string>@@ -121,6 +132,33 @@<string name="download_error_no_url">Could not resolve stream URL for download</string><string name="download_failed">Download failed: %1$s</string><string name="download_started">Download started</string>+ <string name="trakt_watchlist_add">Add to Trakt watchlist</string>+ <string name="trakt_watchlist_connect">Connect Trakt in Settings</string>+ <string name="trakt_watchlist_failed">Could not update the Trakt watchlist. Try again.</string>+ <string name="trakt_favorite_sync_failed">StreamVault saved the change, but could not update Trakt Favorites. Try again.</string>+ <string name="trakt_watchlist_load">Load Trakt watchlist</string>+ <string name="trakt_watchlist_remove">Remove from Trakt watchlist</string>+ <string name="trakt_custom_lists_action">Trakt Lists</string>+ <string name="trakt_custom_lists_title">Your Trakt lists</string>+ <string name="trakt_custom_lists_for_item">Manage %1$s in a list</string>+ <string name="trakt_custom_lists_loading">Loading list information…</string>+ <string name="trakt_custom_lists_connect_first">Connect Trakt in Settings to use your lists.</string>+ <string name="trakt_custom_lists_empty">You don’t have any custom Trakt lists yet.</string>+ <string name="trakt_custom_lists_failed">Could not load or update this Trakt list. Try again.</string>+ <string name="trakt_custom_lists_incognito">Trakt lists are unavailable while Incognito mode is on.</string>+ <string name="trakt_custom_lists_too_large">This list is too large to load completely in StreamVault.</string>+ <string name="trakt_custom_list_open">%1$s · %2$d items</string>+ <string name="trakt_custom_list_contains_item">%1$s is in this list.</string>+ <string name="trakt_custom_list_does_not_contain_item">%1$s is not in this list.</string>+ <string name="trakt_custom_list_add_item">Add to list</string>+ <string name="trakt_custom_lists_create_new">Create new list</string>+ <string name="trakt_custom_lists_name">List name</string>+ <string name="trakt_custom_lists_optional_description">Description (optional)</string>+ <string name="trakt_custom_lists_private_note">New lists are private on Trakt.</string>+ <string name="trakt_custom_lists_create">Create private list</string>+ <string name="trakt_custom_list_remove_item">Remove</string>+ <string name="trakt_custom_list_items_truncated">Showing the first 200 items.</string>+ <string name="trakt_custom_lists_back">Back to lists</string><string name="favorites_add">Add to favourites</string><string name="favorites_all_favorites">All Favorites</string><string name="favorites_cancel">Back: cancel</string>@@ -343,6 +381,17 @@<string name="vod_classic_recently_added">Recently Added</string><string name="vod_classic_results_count">%1$d items</string><string name="vod_external_ratings_heading">Ratings</string>+ <string name="trakt_rating_action">Rate on Trakt</string>+ <string name="trakt_rating_dialog_message">Choose a rating from 1 to 10.</string>+ <string name="trakt_rating_current">Your Trakt rating: %1$d/10</string>+ <string name="trakt_rating_saved">Your rating was saved to Trakt.</string>+ <string name="trakt_rating_failed">Could not save your rating to Trakt.</string>+ <string name="trakt_custom_lists_choose_item">Choose what to add or remove</string>+ <string name="trakt_custom_lists_movies">Movie</string>+ <string name="trakt_custom_lists_series">Series</string>+ <string name="trakt_custom_lists_seasons_count">Seasons (%1$d)</string>+ <string name="trakt_custom_lists_episodes_count">Episodes (%1$d)</string>+ <string name="trakt_custom_lists_change_item">Change title</string><string name="vod_rating_imdb">IMDb</string><string name="vod_rating_metacritic">Metacritic</string><string name="vod_rating_rotten_tomatoes">Rotten Tomatoes</string>@@ -351,4 +400,4 @@<string name="vod_sync_needed_title">Sync needed</string><string name="vod_unavailable_subtitle">This provider exposes separate Movies and Series catalogs.</string><string name="vod_unavailable_title">VOD is unavailable</string>-</resources>\ No newline at end of file+</resources>diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/CatalogDownloadBehaviorTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/CatalogDownloadBehaviorTest.ktindex 5a56461b..694eea9d 100644--- a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/CatalogDownloadBehaviorTest.kt+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/CatalogDownloadBehaviorTest.kt@@ -163,7 +163,10 @@ class CatalogDownloadBehaviorTest {},downloadManager = downloadManager,downloadStarter = starter,- castPort = EmptyCatalogCastPort()+ castPort = EmptyCatalogCastPort(),+ traktWatchlist = NoopTraktWatchlist(),+ traktFavorites = NoopTraktFavorites(),+ traktRatings = NoopTraktRatings(),)}diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktFavorites.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktFavorites.ktnew file mode 100644index 00000000..18b5304d--- /dev/null+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktFavorites.kt@@ -0,0 +1,12 @@+package com.streamvault.feature.catalog.presentation++import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavorites++internal class NoopTraktFavorites : TraktFavorites {+ override suspend fun setFavorited(+ identity: TraktFavoriteIdentity,+ favorited: Boolean,+ ) = TraktFavoriteActionResult.Success+}diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktRatings.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktRatings.ktnew file mode 100644index 00000000..aa4ecebb--- /dev/null+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktRatings.kt@@ -0,0 +1,19 @@+package com.streamvault.feature.catalog.presentation++import com.streamvault.domain.trakt.TraktRatingActionResult+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingRefreshResult+import com.streamvault.domain.trakt.TraktRatings+import com.streamvault.domain.trakt.TraktRatingsState+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktRatingFailure+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow++internal class NoopTraktRatings : TraktRatings {+ private val mutableState = MutableStateFlow(TraktRatingsState())+ override val state = mutableState.asStateFlow()+ override suspend fun refresh(type: TraktRatingType, force: Boolean) =+ TraktRatingRefreshResult.Failure(TraktRatingFailure.DISCONNECTED)+ override suspend fun setRating(identity: TraktRatingIdentity, rating: Int) = TraktRatingActionResult.Success+}diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktWatchlist.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktWatchlist.ktnew file mode 100644index 00000000..d601aff4--- /dev/null+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/NoopTraktWatchlist.kt@@ -0,0 +1,19 @@+package com.streamvault.feature.catalog.presentation++import com.streamvault.domain.trakt.TraktWatchlist+import com.streamvault.domain.trakt.TraktWatchlistActionResult+import com.streamvault.domain.trakt.TraktWatchlistFailure+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistRefreshResult+import com.streamvault.domain.trakt.TraktWatchlistState+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow++internal class NoopTraktWatchlist : TraktWatchlist {+ private val mutableState = MutableStateFlow(TraktWatchlistState())+ override val state = mutableState.asStateFlow()+ override suspend fun refresh(force: Boolean) =+ TraktWatchlistRefreshResult.Failure(TraktWatchlistFailure.DISCONNECTED)+ override suspend fun setWatchlisted(identity: TraktWatchlistIdentity, watchlisted: Boolean) =+ TraktWatchlistActionResult.Failure(TraktWatchlistFailure.DISCONNECTED)+}diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelvesTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelvesTest.ktindex 516d38f9..92984064 100644--- a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelvesTest.kt+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/dashboard/DashboardHomeShelvesTest.kt@@ -4,6 +4,7 @@ import com.google.common.truth.Truth.assertThatimport com.streamvault.domain.model.AppHomeDashboardShelfimport com.streamvault.domain.model.Channelimport com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Seriesimport org.junit.Testclass DashboardHomeShelvesTest {@@ -48,6 +49,23 @@ class DashboardHomeShelvesTest {).inOrder()}+ @Test+ fun `resolveVisibleDashboardShelves shows Trakt watchlist shelves when they have content`() {+ val uiState = DashboardUiState(+ homeDashboardShelves = listOf(+ AppHomeDashboardShelf.TRAKT_WATCHLIST_MOVIES,+ AppHomeDashboardShelf.TRAKT_WATCHLIST_SERIES+ ),+ traktWatchlistMovies = listOf(Movie(id = 30L, name = "Watchlisted movie")),+ traktWatchlistSeries = listOf(Series(id = 31L, name = "Watchlisted show"))+ )++ assertThat(resolveVisibleDashboardShelves(uiState)).containsExactly(+ AppHomeDashboardShelf.TRAKT_WATCHLIST_MOVIES,+ AppHomeDashboardShelf.TRAKT_WATCHLIST_SERIES+ ).inOrder()+ }+@Testfun `resolveVisibleDashboardShelves shows pinned categories when they have content`() {val uiState = DashboardUiState(diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/dashboard/TraktWatchlistShelvesTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/dashboard/TraktWatchlistShelvesTest.ktnew file mode 100644index 00000000..ae82255c--- /dev/null+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/dashboard/TraktWatchlistShelvesTest.kt@@ -0,0 +1,88 @@+package com.streamvault.feature.catalog.presentation.dashboard++import com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Series+import com.streamvault.domain.trakt.TraktWatchlistIdentity+import com.streamvault.domain.trakt.TraktWatchlistType+import org.junit.Test++class TraktWatchlistShelvesTest {++ @Test+ fun `movie shelf follows Trakt order and skips items absent from the active provider`() {+ val watchlist = listOf(+ TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 200L),+ TraktWatchlistIdentity(TraktWatchlistType.SHOW, 400L),+ TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 999L),+ TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 100L)+ )+ val movieA = Movie(id = 1L, name = "First", tmdbId = 100L)+ val movieB = Movie(id = 2L, name = "Second", tmdbId = 200L)++ val result = orderedWatchlistItems(+ watchlistItems = watchlist,+ type = TraktWatchlistType.MOVIE,+ catalogItems = listOf(movieA, movieB),+ tmdbIdOf = Movie::tmdbId,+ idOf = Movie::id,+ limit = 12+ )++ assertThat(result).containsExactly(movieB, movieA).inOrder()+ }++ @Test+ fun `show shelf contains only shows and respects its item limit`() {+ val watchlist = listOf(+ TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 10L),+ TraktWatchlistIdentity(TraktWatchlistType.SHOW, 30L),+ TraktWatchlistIdentity(TraktWatchlistType.SHOW, 20L)+ )+ val first = Series(id = 3L, name = "First", tmdbId = 30L)+ val second = Series(id = 2L, name = "Second", tmdbId = 20L)++ val result = orderedWatchlistItems(+ watchlistItems = watchlist,+ type = TraktWatchlistType.SHOW,+ catalogItems = listOf(second, first),+ tmdbIdOf = Series::tmdbId,+ idOf = Series::id,+ limit = 1+ )++ assertThat(result).containsExactly(first)+ }++ @Test+ fun `shelf ignores catalog rows without a usable TMDB id`() {+ val movie = Movie(id = 1L, name = "No match")++ val result = orderedWatchlistItems(+ watchlistItems = listOf(TraktWatchlistIdentity(TraktWatchlistType.MOVIE, 50L)),+ type = TraktWatchlistType.MOVIE,+ catalogItems = listOf(movie),+ tmdbIdOf = Movie::tmdbId,+ idOf = Movie::id,+ limit = 12+ )++ assertThat(result).isEmpty()+ }++ @Test+ fun `discovery shelf follows Trakt rank and skips titles absent from the provider`() {+ val first = Movie(id = 1L, name = "First", tmdbId = 603L)+ val second = Movie(id = 2L, name = "Second", tmdbId = 550L)++ val result = orderedDiscoveryItems(+ tmdbIds = listOf(550L, 999L, 603L),+ catalogItems = listOf(first, second),+ tmdbIdOf = Movie::tmdbId,+ idOf = Movie::id,+ limit = 10+ )++ assertThat(result).containsExactly(second, first).inOrder()+ }+}diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModelTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModelTest.ktindex 0f43a54f..2c3418bf 100644--- a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModelTest.kt+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/favorites/FavoritesViewModelTest.kt@@ -81,6 +81,7 @@ class FavoritesViewModelTest {providerRepository = providerRepository,preferencesRepository = preferencesRepository,getContinueWatching = getContinueWatching,+ traktFavorites = com.streamvault.feature.catalog.presentation.NoopTraktFavorites(),)}@@ -145,6 +146,7 @@ class FavoritesViewModelTest {providerRepository = providerRepository,preferencesRepository = preferencesRepository,getContinueWatching = getContinueWatching,+ traktFavorites = com.streamvault.feature.catalog.presentation.NoopTraktFavorites(),)advanceUntilIdle()@@ -209,6 +211,7 @@ class FavoritesViewModelTest {providerRepository = providerRepository,preferencesRepository = preferencesRepository,getContinueWatching = getContinueWatching,+ traktFavorites = com.streamvault.feature.catalog.presentation.NoopTraktFavorites(),)advanceUntilIdle()diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModelCastingTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModelCastingTest.ktindex 51b2940f..5f831e09 100644--- a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModelCastingTest.kt+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/movies/MovieDetailViewModelCastingTest.kt@@ -24,12 +24,24 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.MovieRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepository+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktRatingActionResult+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktRatingRefreshResult+import com.streamvault.domain.trakt.TraktRatings+import com.streamvault.domain.trakt.TraktRatingsState+import kotlinx.coroutines.CompletableDeferredimport kotlinx.coroutines.cancelimport kotlinx.coroutines.asyncimport kotlinx.coroutines.CoroutineStartimport kotlinx.coroutines.flow.MutableSharedFlowimport kotlinx.coroutines.flow.SharedFlowimport kotlinx.coroutines.flow.asSharedFlow+import kotlinx.coroutines.flow.asStateFlowimport kotlinx.coroutines.flow.firstimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.runBlocking@@ -47,6 +59,25 @@ class MovieDetailViewModelCastingTest {@get:Ruleval mainDispatcherRule = CatalogMainDispatcherRule()+ @Test+ fun `rateOnTrakt sends exact movie identity and records successful rating`() = runBlocking {+ val ratings = RecordingTraktRatings()+ val viewModel = createViewModel(movie = movie().copy(tmdbId = 603L), traktRatings = ratings)++ try {+ viewModel.uiState.first { it.movie != null }+ val event = async(start = CoroutineStart.UNDISPATCHED) { viewModel.uiEvents.first() }+ viewModel.rateOnTrakt(8)++ assertThat(withTimeout(5_000L) { event.await() })+ .isEqualTo(CatalogUiEvent.ShowMessage(CatalogMessage.TraktRatingSaved))+ assertThat(ratings.writes).containsExactly(TraktRatingIdentity(TraktRatingType.MOVIE, 603L) to 8)+ assertThat(viewModel.uiState.value.traktUserRating).isEqualTo(8)+ } finally {+ viewModel.viewModelScope.cancel()+ }+ }+@Testfun `castMovie emits route chooser and preserves resume position`() = runBlocking {val movie = movie(watchProgress = 42_000L)@@ -163,6 +194,25 @@ class MovieDetailViewModelCastingTest {}}+ @Test+ fun `heart toggle also syncs the movie TMDB id to Trakt favorites`() = runBlocking {+ val favorites = RecordingTraktFavorites()+ val viewModel = createViewModel(movie = movie().copy(tmdbId = 603L), traktFavorites = favorites)++ try {+ withTimeout(5_000L) { viewModel.uiState.first { it.movie != null } }+ viewModel.toggleFavorite()++ assertThat(withTimeout(5_000L) { favorites.completed.await() }).isEqualTo(Unit)+ assertThat(favorites.writes).containsExactly(+ TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603L) to true,+ )+ assertThat(viewModel.uiState.value.movie?.isFavorite).isTrue()+ } finally {+ viewModel.viewModelScope.cancel()+ }+ }+@Testfun `castMovie explains streams that need header rewrite when cast remains unsupported`() = runBlocking {val castPort = FakeCatalogCastPort(CatalogCastStartResult.Unsupported(CatalogMessage.CastUnsupported))@@ -190,7 +240,9 @@ class MovieDetailViewModelCastingTest {private suspend fun createViewModel(movie: Movie = movie(),streamInfo: StreamInfo = StreamInfo(url = "https://example.test/movie.m3u8"),- castPort: FakeCatalogCastPort = FakeCatalogCastPort()+ castPort: FakeCatalogCastPort = FakeCatalogCastPort(),+ traktFavorites: TraktFavorites = com.streamvault.feature.catalog.presentation.NoopTraktFavorites(),+ traktRatings: TraktRatings = com.streamvault.feature.catalog.presentation.NoopTraktRatings(),): MovieDetailViewModel {val provider = Provider(id = movie.providerId,@@ -243,10 +295,24 @@ class MovieDetailViewModelCastingTest {downloadStarter = object : com.streamvault.feature.catalog.api.CatalogDownloadStarter {override fun startDownload(downloadId: String) = Unit},- castPort = castPort+ castPort = castPort,+ traktWatchlist = com.streamvault.feature.catalog.presentation.NoopTraktWatchlist(),+ traktFavorites = traktFavorites,+ traktRatings = traktRatings,)}+ private class RecordingTraktFavorites : TraktFavorites {+ val writes = mutableListOf<Pair<TraktFavoriteIdentity, Boolean>>()+ val completed = CompletableDeferred<Unit>()++ override suspend fun setFavorited(identity: TraktFavoriteIdentity, favorited: Boolean): TraktFavoriteActionResult {+ writes += identity to favorited+ completed.complete(Unit)+ return TraktFavoriteActionResult.Success+ }+ }+private class FakeCatalogCastPort(var result: CatalogCastStartResult = CatalogCastStartResult.Started) : CatalogCastPort {@@ -267,6 +333,18 @@ class MovieDetailViewModelCastingTest {}}+ private class RecordingTraktRatings : TraktRatings {+ private val mutableState = kotlinx.coroutines.flow.MutableStateFlow(TraktRatingsState())+ override val state = mutableState.asStateFlow()+ val writes = mutableListOf<Pair<TraktRatingIdentity, Int>>()+ override suspend fun refresh(type: TraktRatingType, force: Boolean) = TraktRatingRefreshResult.Success(0)+ override suspend fun setRating(identity: TraktRatingIdentity, rating: Int): TraktRatingActionResult {+ writes += identity to rating+ mutableState.value = mutableState.value.copy(ratings = mutableState.value.ratings + (identity to rating))+ return TraktRatingActionResult.Success+ }+ }+private companion object {fun movie(watchProgress: Long = 0L) = Movie(id = 10L,diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/search/SearchViewModelTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/search/SearchViewModelTest.ktindex a4f14ce4..f677a585 100644--- a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/search/SearchViewModelTest.kt+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/search/SearchViewModelTest.kt@@ -7,6 +7,7 @@ import com.streamvault.domain.model.LegacyProvider as Providerimport com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.SearchHistoryScopeimport com.streamvault.domain.model.Series+import com.streamvault.domain.model.ContentTypeimport com.streamvault.data.preferences.PreferencesRepositoryimport com.streamvault.domain.manager.ParentalControlManagerimport com.streamvault.domain.manager.RecordingManager@@ -15,6 +16,10 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.usecase.SearchContentimport com.streamvault.domain.usecase.SearchContentResult+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavoritesimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.ExperimentalCoroutinesApiimport kotlinx.coroutines.delay@@ -67,7 +72,8 @@ class SearchViewModelTest {parentalControlManager,favoriteRepository,categoryRepository,- recordingManager+ recordingManager,+ com.streamvault.feature.catalog.presentation.NoopTraktFavorites())}@@ -121,7 +127,8 @@ class SearchViewModelTest {parentalControlManager,favoriteRepository,categoryRepository,- recordingManager+ recordingManager,+ com.streamvault.feature.catalog.presentation.NoopTraktFavorites())val collectorJob = backgroundScope.launch { viewModel.uiState.collect { } }@@ -162,7 +169,8 @@ class SearchViewModelTest {parentalControlManager,favoriteRepository,categoryRepository,- recordingManager+ recordingManager,+ com.streamvault.feature.catalog.presentation.NoopTraktFavorites())val collectorJob = backgroundScope.launch { viewModel.uiState.collect { } }@@ -211,7 +219,8 @@ class SearchViewModelTest {parentalControlManager,favoriteRepository,categoryRepository,- recordingManager+ recordingManager,+ com.streamvault.feature.catalog.presentation.NoopTraktFavorites())val collectorJob = backgroundScope.launch { viewModel.uiState.collect { } }@@ -226,4 +235,41 @@ class SearchViewModelTest {assertThat(viewModel.uiState.value.hasSearched).isTrue()collectorJob.cancel()}++ @Test+ fun `movie favorite action also syncs its TMDB id to Trakt`() = runTest {+ val provider = Provider(id = 5L, name = "Provider", type = ProviderType.M3U, serverUrl = "http://test")+ whenever(providerRepository.getActiveProvider()).thenReturn(flowOf(provider))+ val favorites = RecordingTraktFavorites()+ viewModel = SearchViewModel(+ providerRepository,+ searchContent,+ preferencesRepository,+ parentalControlManager,+ favoriteRepository,+ categoryRepository,+ recordingManager,+ favorites,+ )+ val collectorJob = backgroundScope.launch { viewModel.uiState.collect { } }+ advanceUntilIdle()++ viewModel.toggleFavorite(20L, ContentType.MOVIE, currentlyFavorite = false, tmdbId = 603L)+ advanceUntilIdle()++ verify(favoriteRepository).addFavorite(5L, 20L, ContentType.MOVIE)+ assertThat(favorites.writes).containsExactly(+ TraktFavoriteIdentity(TraktFavoriteType.MOVIE, 603L) to true,+ )+ collectorJob.cancel()+ }++ private class RecordingTraktFavorites : TraktFavorites {+ val writes = mutableListOf<Pair<TraktFavoriteIdentity, Boolean>>()++ override suspend fun setFavorited(identity: TraktFavoriteIdentity, favorited: Boolean): TraktFavoriteActionResult {+ writes += identity to favorited+ return TraktFavoriteActionResult.Success+ }+ }}diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModelCastingTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModelCastingTest.ktindex 6d5814fe..4eb12740 100644--- a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModelCastingTest.kt+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/series/SeriesDetailViewModelCastingTest.kt@@ -27,12 +27,24 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.SeriesRepository+import com.streamvault.domain.trakt.TraktFavoriteActionResult+import com.streamvault.domain.trakt.TraktFavoriteIdentity+import com.streamvault.domain.trakt.TraktFavoriteType+import com.streamvault.domain.trakt.TraktFavorites+import com.streamvault.domain.trakt.TraktRatingActionResult+import com.streamvault.domain.trakt.TraktRatingIdentity+import com.streamvault.domain.trakt.TraktRatingType+import com.streamvault.domain.trakt.TraktRatingRefreshResult+import com.streamvault.domain.trakt.TraktRatings+import com.streamvault.domain.trakt.TraktRatingsState+import kotlinx.coroutines.CompletableDeferredimport kotlinx.coroutines.cancelimport kotlinx.coroutines.asyncimport kotlinx.coroutines.CoroutineStartimport kotlinx.coroutines.flow.MutableSharedFlowimport kotlinx.coroutines.flow.SharedFlowimport kotlinx.coroutines.flow.asSharedFlow+import kotlinx.coroutines.flow.asStateFlowimport kotlinx.coroutines.flow.firstimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.runBlocking@@ -50,6 +62,25 @@ class SeriesDetailViewModelCastingTest {@get:Ruleval mainDispatcherRule = CatalogMainDispatcherRule()+ @Test+ fun `rateOnTrakt sends exact show identity and records successful rating`() = runBlocking {+ val ratings = RecordingTraktRatings()+ val viewModel = createViewModel(series = series().copy(tmdbId = 1396L), traktRatings = ratings)++ try {+ viewModel.uiState.first { it.series != null }+ val event = async(start = CoroutineStart.UNDISPATCHED) { viewModel.uiEvents.first() }+ viewModel.rateOnTrakt(9)++ assertThat(withTimeout(5_000L) { event.await() })+ .isEqualTo(CatalogUiEvent.ShowMessage(CatalogMessage.TraktRatingSaved))+ assertThat(ratings.writes).containsExactly(TraktRatingIdentity(TraktRatingType.SHOW, 1396L) to 9)+ assertThat(viewModel.uiState.value.traktUserRating).isEqualTo(9)+ } finally {+ viewModel.viewModelScope.cancel()+ }+ }+@Testfun `castEpisode uses selected episode and preserves watch progress`() = runBlocking {val selectedEpisode = episode(id = 22L, episodeNumber = 2, watchProgress = 65_000L)@@ -146,6 +177,25 @@ class SeriesDetailViewModelCastingTest {}}+ @Test+ fun `heart toggle also syncs the series TMDB id to Trakt favorites`() = runBlocking {+ val favorites = RecordingTraktFavorites()+ val viewModel = createViewModel(series = series().copy(tmdbId = 1396L), traktFavorites = favorites)++ try {+ withTimeout(5_000L) { viewModel.uiState.first { it.series != null } }+ viewModel.toggleFavorite()++ assertThat(withTimeout(5_000L) { favorites.completed.await() }).isEqualTo(Unit)+ assertThat(favorites.writes).containsExactly(+ TraktFavoriteIdentity(TraktFavoriteType.SHOW, 1396L) to true,+ )+ assertThat(viewModel.uiState.value.series?.isFavorite).isTrue()+ } finally {+ viewModel.viewModelScope.cancel()+ }+ }+@Testfun `castEpisode explains streams that need proxy rewrite when cast remains unsupported`() = runBlocking {val castPort = FakeCatalogCastPort(CatalogCastStartResult.Unsupported(CatalogMessage.CastUnsupported))@@ -174,7 +224,9 @@ class SeriesDetailViewModelCastingTest {private suspend fun createViewModel(series: Series = series(),streamInfo: StreamInfo = StreamInfo(url = "https://example.test/episode.m3u8"),- castPort: FakeCatalogCastPort = FakeCatalogCastPort()+ castPort: FakeCatalogCastPort = FakeCatalogCastPort(),+ traktFavorites: TraktFavorites = com.streamvault.feature.catalog.presentation.NoopTraktFavorites(),+ traktRatings: TraktRatings = com.streamvault.feature.catalog.presentation.NoopTraktRatings(),): SeriesDetailViewModel {val provider = Provider(id = series.providerId,@@ -217,10 +269,24 @@ class SeriesDetailViewModelCastingTest {downloadStarter = object : CatalogDownloadStarter {override fun startDownload(downloadId: String) = Unit},- castPort = castPort+ castPort = castPort,+ traktWatchlist = com.streamvault.feature.catalog.presentation.NoopTraktWatchlist(),+ traktFavorites = traktFavorites,+ traktRatings = traktRatings,)}+ private class RecordingTraktFavorites : TraktFavorites {+ val writes = mutableListOf<Pair<TraktFavoriteIdentity, Boolean>>()+ val completed = CompletableDeferred<Unit>()++ override suspend fun setFavorited(identity: TraktFavoriteIdentity, favorited: Boolean): TraktFavoriteActionResult {+ writes += identity to favorited+ completed.complete(Unit)+ return TraktFavoriteActionResult.Success+ }+ }+private class FakeCatalogCastPort(var result: CatalogCastStartResult = CatalogCastStartResult.Started) : CatalogCastPort {@@ -241,6 +307,18 @@ class SeriesDetailViewModelCastingTest {}}+ private class RecordingTraktRatings : TraktRatings {+ private val mutableState = kotlinx.coroutines.flow.MutableStateFlow(TraktRatingsState())+ override val state = mutableState.asStateFlow()+ val writes = mutableListOf<Pair<TraktRatingIdentity, Int>>()+ override suspend fun refresh(type: TraktRatingType, force: Boolean) = TraktRatingRefreshResult.Success(0)+ override suspend fun setRating(identity: TraktRatingIdentity, rating: Int): TraktRatingActionResult {+ writes += identity to rating+ mutableState.value = mutableState.value.copy(ratings = mutableState.value.ratings + (identity to rating))+ return TraktRatingActionResult.Success+ }+ }+private companion object {fun series(episodes: List<Episode> = listOf(episode())) = Series(id = 30L,diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.ktindex e3b37928..66562032 100644--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.kt+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.kt@@ -97,6 +97,7 @@ import com.streamvault.core.navigation.AppDestinationprivate const val CLOSE_PLAYBACK_CONFIRM_GUARD_MS = 350L+private const val TRAKT_STATUS_BADGE_DURATION_MS = 3_000L@OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class)@Composable@@ -160,6 +161,7 @@ fun PlayerScreen(val videoFormat by viewModel.videoFormat.collectAsStateWithLifecycle()val playerError by viewModel.playerError.collectAsStateWithLifecycle()val playbackResolutionUiState by viewModel.playbackResolutionUiState.collectAsStateWithLifecycle()+ val traktTrackingStatus by viewModel.playerTraktCoordinator.status.collectAsStateWithLifecycle()val currentChannel by viewModel.currentChannel.collectAsStateWithLifecycle()val autoPlayCountdown by viewModel.autoPlayCountdown.collectAsStateWithLifecycle()val skipChapter by viewModel.skipChapter.collectAsStateWithLifecycle()@@ -183,6 +185,7 @@ fun PlayerScreen(var channelInfoSubPanelOpen by remember { mutableStateOf(false) }var showClosePlaybackConfirmation by rememberSaveable { mutableStateOf(false) }var closePlaybackConfirmationOpenedAtMs by remember { mutableStateOf(0L) }+ var showTransientTraktStatus by remember { mutableStateOf(false) }val focusRequester = remember { FocusRequester() }val channelListFocusRequester = remember { FocusRequester() }@@ -203,6 +206,16 @@ fun PlayerScreen(focusRequester.requestFocus()}+ LaunchedEffect(traktTrackingStatus) {+ if (traktTrackingStatus == PlayerTraktTrackingStatus.HIDDEN) {+ showTransientTraktStatus = false+ } else {+ showTransientTraktStatus = true+ delay(TRAKT_STATUS_BADGE_DURATION_MS)+ showTransientTraktStatus = false+ }+ }+LaunchedEffect(playbackPlatformHost, streamUrl, playbackState, isPlaying, videoFormat.width, videoFormat.height, videoFormat.pixelWidthHeightRatio) {playbackPlatformHost?.updatePictureInPictureState(PlaybackPictureInPictureState(@@ -754,6 +767,18 @@ fun PlayerScreen(.padding(start = 18.dp, top = 18.dp))+ AnimatedVisibility(+ visible = traktTrackingStatus != PlayerTraktTrackingStatus.HIDDEN &&+ (showControls || showTransientTraktStatus),+ enter = fadeIn(tween(150)),+ exit = fadeOut(tween(250)),+ modifier = Modifier+ .align(Alignment.TopStart)+ .padding(start = 18.dp, top = 72.dp)+ ) {+ PlayerTraktStatusOverlay(status = traktTrackingStatus)+ }+when (val resolutionState = playbackResolutionUiState) {PlaybackResolutionUiState.Resolving -> Box(modifier = Modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.82f)),diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktCoordinator.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktCoordinator.ktnew file mode 100644index 00000000..5dcb6f20--- /dev/null+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktCoordinator.kt@@ -0,0 +1,212 @@+package com.streamvault.feature.playback.player++import com.streamvault.domain.trakt.*+import com.streamvault.domain.trakt.TraktFeaturePreferences+import kotlinx.coroutines.CoroutineScope+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Job+import kotlinx.coroutines.channels.Channel+import kotlinx.coroutines.channels.BufferOverflow+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.StateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.flow.flowOf+import kotlinx.coroutines.launch+import javax.inject.Inject++enum class TraktPlaybackEligibility { SUPPORTED, LIVE, CATCH_UP, OTHER }++enum class PlayerTraktTrackingStatus {+ HIDDEN,+ CONNECT_REQUIRED,+ NOT_SUPPORTED,+ NO_MATCH,+ STARTING,+ TRACKING,+ PAUSED,+ FAILED,+ SENT,+}++/** One worker, a bounded transition queue, and no queued position ticks. */+class PlayerTraktCoordinator @Inject constructor(+ private val account: TraktAccount,+ private val scrobbler: TraktScrobbler,+ private val featurePreferences: TraktFeaturePreferences,+ scope: CoroutineScope,+) {+ constructor(account: TraktAccount, scrobbler: TraktScrobbler, scope: CoroutineScope) : this(+ account,+ scrobbler,+ object : TraktFeaturePreferences {+ override val scrobblingEnabled = flowOf(true)+ override suspend fun setScrobblingEnabled(enabled: Boolean) = Unit+ override val historySyncEnabled = flowOf(true)+ override suspend fun setHistorySyncEnabled(enabled: Boolean) = Unit+ },+ scope,+ )++ private data class Observation(val generation: Long, val identity: TraktMediaIdentity?,+ val phase: TraktPlaybackPhase, val position: Long, val duration: Long)+ private val observations = Channel<Observation>(32, BufferOverflow.DROP_OLDEST)+ private var sourceSession = Long.MIN_VALUE+ private var connected = false+ @Volatile private var scrobblingEnabled = true+ private var generation = 0L+ @Volatile private var latest: Observation? = null+ @Volatile private var remoteMedia: TraktMediaIdentity? = null+ private val mutableStatus = MutableStateFlow(PlayerTraktTrackingStatus.HIDDEN)+ val status: StateFlow<PlayerTraktTrackingStatus> = mutableStatus.asStateFlow()+ private val planner = TraktScrobblePlanner()+ private var terminalStatus: PlayerTraktTrackingStatus? = null+ private val preferenceJob: Job++ init {+ preferenceJob = scope.launch {+ featurePreferences.scrobblingEnabled.collect { enabled ->+ val previous = scrobblingEnabled+ scrobblingEnabled = enabled+ if (previous && !enabled) synchronized(this@PlayerTraktCoordinator) {+ latest?.let { active ->+ val paused = active.copy(phase = TraktPlaybackPhase.STOPPED)+ latest = paused+ observations.trySend(paused)+ mutableStatus.value = PlayerTraktTrackingStatus.HIDDEN+ }+ }+ }+ }+ scope.launch {+ try {+ account.load()+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ }+ for (observation in observations) {+ val events = planner.observe(observation.generation, observation.identity,+ observation.phase, observation.position, observation.duration)+ for (event in events) {+ if (event.action != TraktScrobbleAction.STOP && latest?.generation != observation.generation) continue+ // A queued start may still be waiting behind another request when the user+ // disables scrobbling. Do not begin a new remote session after that choice.+ if (!scrobblingEnabled && event.action == TraktScrobbleAction.START) continue+ // A skipped/failed start must not later create watched history via stop.+ if (event.action != TraktScrobbleAction.START && remoteMedia != event.media) continue+ // Turning tracking off ends an active remote session without making a stop+ // request that could turn a high-progress title into watched history.+ val outgoing = if (!scrobblingEnabled && event.action == TraktScrobbleAction.STOP) {+ event.copy(action = TraktScrobbleAction.PAUSE)+ } else event+ val outcome = try {+ scrobbler.send(outgoing)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ // Optional tracking must never crash playback or retry an ambiguous write.+ TraktScrobbleOutcome.FAILED+ }+ if (event.action == TraktScrobbleAction.START && outcome == TraktScrobbleOutcome.SENT) {+ remoteMedia = event.media+ }+ if (event.action == TraktScrobbleAction.STOP) remoteMedia = null+ publishOutcome(observation.generation, event.action, outcome)+ }+ }+ }+ }++ @Synchronized+ fun report(session: Long, identity: TraktMediaIdentity?, phase: TraktPlaybackPhase,+ positionMs: Long, durationMs: Long,+ eligibility: TraktPlaybackEligibility = TraktPlaybackEligibility.SUPPORTED) {+ if (session < sourceSession) return+ val isConnected = account.state.value.connected+ val isTrackingEnabled = scrobblingEnabled+ val previous = latest+ val changedSession = session != sourceSession || connected != isConnected+ if (changedSession) {+ // Preserve the most recent old position before accepting a new item's position.+ previous?.copy(phase = if (previous.phase == TraktPlaybackPhase.ENDED)+ TraktPlaybackPhase.ENDED else TraktPlaybackPhase.STOPPED)?.let { observations.trySend(it) }+ generation+++ terminalStatus = null+ }+ sourceSession = session+ connected = isConnected+ val observation = Observation(+ generation,+ identity.takeIf { isConnected && isTrackingEnabled && eligibility == TraktPlaybackEligibility.SUPPORTED },+ phase,+ positionMs,+ durationMs,+ )+ latest = observation+ updateVisibleStatus(identity, phase, durationMs, isConnected, eligibility, isTrackingEnabled)+ val durationBecameAvailable = (previous?.duration ?: 0L) <= 0L && durationMs > 0L+ if (changedSession || previous?.identity != observation.identity || previous?.phase != phase || durationBecameAvailable) {+ observations.trySend(observation)+ }+ }++ @Synchronized+ private fun updateVisibleStatus(+ identity: TraktMediaIdentity?,+ phase: TraktPlaybackPhase,+ durationMs: Long,+ isConnected: Boolean,+ eligibility: TraktPlaybackEligibility,+ isTrackingEnabled: Boolean,+ ) {+ val next = when {+ !isTrackingEnabled -> PlayerTraktTrackingStatus.HIDDEN+ eligibility != TraktPlaybackEligibility.SUPPORTED -> PlayerTraktTrackingStatus.NOT_SUPPORTED+ !isConnected -> PlayerTraktTrackingStatus.CONNECT_REQUIRED+ identity == null -> PlayerTraktTrackingStatus.NO_MATCH+ terminalStatus != null -> terminalStatus!!+ phase == TraktPlaybackPhase.STOPPED || phase == TraktPlaybackPhase.ENDED -> mutableStatus.value+ remoteMedia == identity && phase == TraktPlaybackPhase.PAUSED -> PlayerTraktTrackingStatus.PAUSED+ remoteMedia == identity -> PlayerTraktTrackingStatus.TRACKING+ phase == TraktPlaybackPhase.PLAYING && durationMs > 0L -> PlayerTraktTrackingStatus.STARTING+ phase == TraktPlaybackPhase.BUFFERING -> PlayerTraktTrackingStatus.STARTING+ else -> PlayerTraktTrackingStatus.HIDDEN+ }+ mutableStatus.value = next+ }++ @Synchronized+ private fun publishOutcome(+ eventGeneration: Long,+ action: TraktScrobbleAction,+ outcome: TraktScrobbleOutcome,+ ) {+ if (generation != eventGeneration) return+ if (!scrobblingEnabled) {+ mutableStatus.value = PlayerTraktTrackingStatus.HIDDEN+ return+ }+ val next = when (outcome) {+ TraktScrobbleOutcome.SENT -> when (action) {+ TraktScrobbleAction.START -> PlayerTraktTrackingStatus.TRACKING+ TraktScrobbleAction.PAUSE -> PlayerTraktTrackingStatus.PAUSED+ TraktScrobbleAction.STOP -> PlayerTraktTrackingStatus.SENT+ }+ TraktScrobbleOutcome.DUPLICATE -> PlayerTraktTrackingStatus.SENT+ TraktScrobbleOutcome.DISCONNECTED -> PlayerTraktTrackingStatus.CONNECT_REQUIRED+ TraktScrobbleOutcome.UNMATCHED -> PlayerTraktTrackingStatus.NO_MATCH+ TraktScrobbleOutcome.FAILED -> PlayerTraktTrackingStatus.FAILED+ }+ if (next == PlayerTraktTrackingStatus.FAILED ||+ next == PlayerTraktTrackingStatus.NO_MATCH ||+ next == PlayerTraktTrackingStatus.CONNECT_REQUIRED) {+ terminalStatus = next+ }+ mutableStatus.value = next+ }++ @Synchronized+ fun close() {+ preferenceJob.cancel()+ latest?.copy(phase = TraktPlaybackPhase.STOPPED)?.let { observations.trySend(it) }+ observations.close()+ }+}diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktStatusOverlay.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktStatusOverlay.ktnew file mode 100644index 00000000..d898beaf--- /dev/null+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktStatusOverlay.kt@@ -0,0 +1,69 @@+package com.streamvault.feature.playback.player++import androidx.compose.foundation.background+import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.runtime.Composable+import androidx.compose.ui.Alignment+import androidx.compose.ui.Modifier+import androidx.compose.ui.graphics.Color+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.text.font.FontWeight+import androidx.compose.ui.unit.dp+import androidx.tv.material3.MaterialTheme+import androidx.tv.material3.Text+import com.streamvault.feature.playback.R++@Composable+internal fun PlayerTraktStatusOverlay(+ status: PlayerTraktTrackingStatus,+ modifier: Modifier = Modifier,+) {+ if (status == PlayerTraktTrackingStatus.HIDDEN) return++ val label = when (status) {+ PlayerTraktTrackingStatus.HIDDEN -> return+ PlayerTraktTrackingStatus.CONNECT_REQUIRED -> R.string.player_trakt_connect_required+ PlayerTraktTrackingStatus.NOT_SUPPORTED -> R.string.player_trakt_not_supported+ PlayerTraktTrackingStatus.NO_MATCH -> R.string.player_trakt_no_match+ PlayerTraktTrackingStatus.STARTING -> R.string.player_trakt_starting+ PlayerTraktTrackingStatus.TRACKING -> R.string.player_trakt_tracking+ PlayerTraktTrackingStatus.PAUSED -> R.string.player_trakt_paused+ PlayerTraktTrackingStatus.FAILED -> R.string.player_trakt_failed+ PlayerTraktTrackingStatus.SENT -> R.string.player_trakt_sent+ }+ val accent = when (status) {+ PlayerTraktTrackingStatus.TRACKING,+ PlayerTraktTrackingStatus.SENT -> Color(0xFF85E3A8)+ PlayerTraktTrackingStatus.PAUSED,+ PlayerTraktTrackingStatus.STARTING -> Color(0xFF8FC7FF)+ PlayerTraktTrackingStatus.FAILED,+ PlayerTraktTrackingStatus.CONNECT_REQUIRED,+ PlayerTraktTrackingStatus.NO_MATCH,+ PlayerTraktTrackingStatus.NOT_SUPPORTED -> Color(0xFFFFC36A)+ PlayerTraktTrackingStatus.HIDDEN -> Color.Transparent+ }++ Row(+ modifier = modifier+ .background(Color.Black.copy(alpha = 0.72f), RoundedCornerShape(18.dp))+ .padding(horizontal = 12.dp, vertical = 8.dp),+ horizontalArrangement = Arrangement.spacedBy(8.dp),+ verticalAlignment = Alignment.CenterVertically,+ ) {+ Text(+ text = "TRAKT",+ style = MaterialTheme.typography.labelMedium,+ fontWeight = FontWeight.Bold,+ color = accent,+ )+ Text(+ text = stringResource(label),+ style = MaterialTheme.typography.labelMedium,+ color = Color.White,+ maxLines = 1,+ )+ }+}diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktSupport.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktSupport.ktnew file mode 100644index 00000000..7e325dda--- /dev/null+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerTraktSupport.kt@@ -0,0 +1,53 @@+package com.streamvault.feature.playback.player++import com.streamvault.domain.model.ContentType+import com.streamvault.domain.trakt.TraktMediaIdentityResolver+import com.streamvault.domain.trakt.TraktPlaybackPhase+import com.streamvault.player.PlaybackState+import kotlinx.coroutines.CancellationException++internal suspend fun PlayerViewModel.reportTraktPlayback(state: PlaybackState = playerEngine.playbackState.value) {+ val version = prepareRequestVersion+ val identity = if (readySideEffectsRequestVersion != version) null else when (currentContentType) {+ ContentType.MOVIE -> {+ if (traktMovieSession != version) {+ val movie = try {+ playerContentResolver.getMovie(currentContentId)+ } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ null // Tracking metadata failure must not interrupt playback or auto-play.+ }+ if (version != prepareRequestVersion) return+ traktMovieIdentity = movie?.takeIf { it.providerId == currentProviderId }+ ?.let(TraktMediaIdentityResolver::movie)+ traktMovieSession = version+ }+ traktMovieIdentity+ }+ ContentType.SERIES_EPISODE -> currentSeries.value?.let { series ->+ currentEpisode.value?.let { episode -> TraktMediaIdentityResolver.episode(series, episode) }+ }+ else -> null // Live, catch-up, recordings, trailers, and unidentified external URLs are excluded.+ }+ if (version != prepareRequestVersion) return+ playerTraktCoordinator.report(version, identity, traktPlaybackPhase(state, playerEngine.isPlaying.value),+ playerEngine.currentPosition.value, playerEngine.duration.value,+ eligibility = when {+ isCatchUpPlayback() -> TraktPlaybackEligibility.CATCH_UP+ currentContentType == ContentType.LIVE -> TraktPlaybackEligibility.LIVE+ currentContentType == ContentType.MOVIE || currentContentType == ContentType.SERIES_EPISODE ->+ TraktPlaybackEligibility.SUPPORTED+ else -> TraktPlaybackEligibility.OTHER+ })+}++internal fun traktPlaybackPhase(state: PlaybackState, isPlaying: Boolean): TraktPlaybackPhase =+ when (state) {+ PlaybackState.READY -> if (isPlaying) TraktPlaybackPhase.PLAYING else TraktPlaybackPhase.PAUSED+ PlaybackState.BUFFERING -> TraktPlaybackPhase.BUFFERING+ PlaybackState.ENDED -> TraktPlaybackPhase.ENDED+ // Engine replacement/recovery can temporarily enter IDLE/ERROR within the same session.+ // Final stop is owned by session replacement or ViewModel cleanup.+ PlaybackState.IDLE -> TraktPlaybackPhase.BUFFERING+ PlaybackState.ERROR -> TraktPlaybackPhase.PAUSED+ }diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.ktindex f646ed01..c237ae73 100644--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt@@ -76,6 +76,7 @@ class PlayerViewModel @Inject constructor(internal val playerPlaybackContextCoordinator: PlayerPlaybackContextCoordinator,internal val playerRecoveryCoordinator: PlayerRecoveryCoordinator,internal val playerRecoveryExecutionCoordinator: PlayerRecoveryExecutionCoordinator,+ internal val playerTraktCoordinator: PlayerTraktCoordinator,) : ViewModel() {companion object {private const val MIN_WATCHED_FOR_AUTO_PLAY_MS = 5_000L@@ -111,6 +112,8 @@ class PlayerViewModel @Inject constructor(val currentChannel: StateFlow<com.streamvault.domain.model.Channel?> = currentChannelFlow.asStateFlow()private val _currentSeries = MutableStateFlow<Series?>(null)+ internal var traktMovieSession: Long? = null+ internal var traktMovieIdentity: com.streamvault.domain.trakt.TraktMediaIdentity.MovieId? = nullval currentSeries: StateFlow<Series?> = _currentSeries.asStateFlow()private val _currentEpisode = MutableStateFlow<Episode?>(null)@@ -502,6 +505,12 @@ class PlayerViewModel @Inject constructor(init {observeCastPlaybackEvents()+ viewModelScope.launch {+ while (true) {+ reportTraktPlayback()+ delay(500)+ }+ }viewModelScope.launch {activePlayerEngineFlow.flatMapLatest { it.error }.collect { error ->if (error != null) {@@ -513,6 +522,7 @@ class PlayerViewModel @Inject constructor(activePlayerEngineFlow.flatMapLatest { it.playbackState }.collect { state ->_playerDiagnostics.update { it.copy(playbackStateLabel = state.name.replace('_', ' ')) }if (state == PlaybackState.ENDED && lastObservedPlaybackState != PlaybackState.ENDED) {+ reportTraktPlayback(state)handlePlaybackEnded()}lastObservedPlaybackState = state@@ -1689,6 +1699,7 @@ class PlayerViewModel @Inject constructor()?.urloverride fun onCleared() {+ playerTraktCoordinator.close()playbackSessionCoordinator.invalidate()super.onCleared()cleanupAfterCleared(playerEngineCoordinator.mainEngine)diff --git a/feature/playback/src/main/res/values-ar/playback_player_strings.xml b/feature/playback/src/main/res/values-ar/playback_player_strings.xmlindex d462891a..93d94739 100644--- a/feature/playback/src/main/res/values-ar/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-ar/playback_player_strings.xml@@ -200,4 +200,12 @@<string name="series_seasons">المواسم</string><string name="settings_recording_status_recording">جارٍ التسجيل</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">اتصل بـ Trakt من الإعدادات</string>+ <string name="player_trakt_not_supported">يتتبع Trakt الأفلام والحلقات فقط.</string>+ <string name="player_trakt_no_match">لم يتم العثور على تطابق دقيق لهذا العنوان في Trakt.</string>+ <string name="player_trakt_starting">جارٍ بدء التتبع في Trakt…</string>+ <string name="player_trakt_tracking">جارٍ التتبع عبر Trakt</string>+ <string name="player_trakt_paused">تم إيقاف التتبع في Trakt</string>+ <string name="player_trakt_failed">فشل التتبع في Trakt</string>+ <string name="player_trakt_sent">تم الإرسال إلى Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-cs/playback_player_strings.xml b/feature/playback/src/main/res/values-cs/playback_player_strings.xmlindex 8a2a5647..43c5cf58 100644--- a/feature/playback/src/main/res/values-cs/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-cs/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Sezóny</string><string name="settings_recording_status_recording">Nahrávání</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Připojte Trakt v Nastavení</string>+ <string name="player_trakt_not_supported">Trakt sleduje pouze filmy a epizody.</string>+ <string name="player_trakt_no_match">Pro tento titul nebyla nalezena přesná shoda v Trakt.</string>+ <string name="player_trakt_starting">Spouští se sledování přes Trakt…</string>+ <string name="player_trakt_tracking">Trakt sleduje přehrávání</string>+ <string name="player_trakt_paused">Sledování přes Trakt je pozastaveno</string>+ <string name="player_trakt_failed">Sledování přes Trakt selhalo</string>+ <string name="player_trakt_sent">Odesláno do Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-da/playback_player_strings.xml b/feature/playback/src/main/res/values-da/playback_player_strings.xmlindex fd684f03..74b92cf6 100644--- a/feature/playback/src/main/res/values-da/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-da/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Årstider</string><string name="settings_recording_status_recording">Optagelse</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Tilslut Trakt i Indstillinger</string>+ <string name="player_trakt_not_supported">Trakt sporer kun film og afsnit.</string>+ <string name="player_trakt_no_match">Ingen præcis Trakt-match for denne titel.</string>+ <string name="player_trakt_starting">Starter Trakt-sporing…</string>+ <string name="player_trakt_tracking">Trakt sporer afspilningen</string>+ <string name="player_trakt_paused">Trakt-sporing er sat på pause</string>+ <string name="player_trakt_failed">Trakt-sporing mislykkedes</string>+ <string name="player_trakt_sent">Sendt til Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-de/playback_player_strings.xml b/feature/playback/src/main/res/values-de/playback_player_strings.xmlindex 91bba9ff..52779640 100644--- a/feature/playback/src/main/res/values-de/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-de/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Jahreszeiten</string><string name="settings_recording_status_recording">Aufnahme</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Trakt in den Einstellungen verbinden</string>+ <string name="player_trakt_not_supported">Trakt verfolgt nur Filme und Episoden.</string>+ <string name="player_trakt_no_match">Kein genauer Trakt-Treffer für diesen Titel.</string>+ <string name="player_trakt_starting">Trakt-Tracking wird gestartet…</string>+ <string name="player_trakt_tracking">Trakt verfolgt die Wiedergabe</string>+ <string name="player_trakt_paused">Trakt-Tracking pausiert</string>+ <string name="player_trakt_failed">Trakt-Tracking fehlgeschlagen</string>+ <string name="player_trakt_sent">An Trakt gesendet</string></resources>diff --git a/feature/playback/src/main/res/values-el/playback_player_strings.xml b/feature/playback/src/main/res/values-el/playback_player_strings.xmlindex 825c325a..71f06e3f 100644--- a/feature/playback/src/main/res/values-el/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-el/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Σεζόν</string><string name="settings_recording_status_recording">Εγγραφή</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Συνδέστε το Trakt στις Ρυθμίσεις</string>+ <string name="player_trakt_not_supported">Το Trakt παρακολουθεί μόνο ταινίες και επεισόδια.</string>+ <string name="player_trakt_no_match">Δεν βρέθηκε ακριβής αντιστοιχία στο Trakt για αυτόν τον τίτλο.</string>+ <string name="player_trakt_starting">Έναρξη παρακολούθησης Trakt…</string>+ <string name="player_trakt_tracking">Το Trakt παρακολουθεί την αναπαραγωγή</string>+ <string name="player_trakt_paused">Η παρακολούθηση Trakt τέθηκε σε παύση</string>+ <string name="player_trakt_failed">Αποτυχία παρακολούθησης Trakt</string>+ <string name="player_trakt_sent">Στάλθηκε στο Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-es/playback_player_strings.xml b/feature/playback/src/main/res/values-es/playback_player_strings.xmlindex 2fcdf317..8d6d0783 100644--- a/feature/playback/src/main/res/values-es/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-es/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Estaciones</string><string name="settings_recording_status_recording">Grabando</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Conecta Trakt en Ajustes</string>+ <string name="player_trakt_not_supported">Trakt solo registra películas y episodios.</string>+ <string name="player_trakt_no_match">No hay una coincidencia exacta en Trakt para este título.</string>+ <string name="player_trakt_starting">Iniciando el seguimiento de Trakt…</string>+ <string name="player_trakt_tracking">Trakt está registrando la reproducción</string>+ <string name="player_trakt_paused">Seguimiento de Trakt en pausa</string>+ <string name="player_trakt_failed">Error en el seguimiento de Trakt</string>+ <string name="player_trakt_sent">Enviado a Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-fi/playback_player_strings.xml b/feature/playback/src/main/res/values-fi/playback_player_strings.xmlindex 9140ddab..b7808d9a 100644--- a/feature/playback/src/main/res/values-fi/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-fi/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Vuodenajat</string><string name="settings_recording_status_recording">Tallennus</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Yhdistä Trakt Asetuksissa</string>+ <string name="player_trakt_not_supported">Trakt seuraa vain elokuvia ja jaksoja.</string>+ <string name="player_trakt_no_match">Nimikkeelle ei löytynyt tarkkaa Trakt-osumaa.</string>+ <string name="player_trakt_starting">Trakt-seuranta alkaa…</string>+ <string name="player_trakt_tracking">Trakt seuraa toistoa</string>+ <string name="player_trakt_paused">Trakt-seuranta tauolla</string>+ <string name="player_trakt_failed">Trakt-seuranta epäonnistui</string>+ <string name="player_trakt_sent">Lähetetty Traktiin</string></resources>diff --git a/feature/playback/src/main/res/values-fr/playback_player_strings.xml b/feature/playback/src/main/res/values-fr/playback_player_strings.xmlindex 80cf6d98..00a0f071 100644--- a/feature/playback/src/main/res/values-fr/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-fr/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Saisons</string><string name="settings_recording_status_recording">Enregistrement</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Connectez Trakt dans les paramètres</string>+ <string name="player_trakt_not_supported">Trakt suit uniquement les films et les épisodes.</string>+ <string name="player_trakt_no_match">Aucune correspondance exacte dans Trakt pour ce titre.</string>+ <string name="player_trakt_starting">Démarrage du suivi Trakt…</string>+ <string name="player_trakt_tracking">Suivi Trakt en cours</string>+ <string name="player_trakt_paused">Suivi Trakt en pause</string>+ <string name="player_trakt_failed">Échec du suivi Trakt</string>+ <string name="player_trakt_sent">Envoyé à Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-hu/playback_player_strings.xml b/feature/playback/src/main/res/values-hu/playback_player_strings.xmlindex e2406e87..e82db161 100644--- a/feature/playback/src/main/res/values-hu/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-hu/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Évszakok</string><string name="settings_recording_status_recording">Felvétel</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Csatlakoztasd a Traktot a Beállításokban</string>+ <string name="player_trakt_not_supported">A Trakt csak filmeket és epizódokat követ.</string>+ <string name="player_trakt_no_match">Nincs pontos Trakt-találat ehhez a címhez.</string>+ <string name="player_trakt_starting">Trakt-követés indítása…</string>+ <string name="player_trakt_tracking">A Trakt követi a lejátszást</string>+ <string name="player_trakt_paused">A Trakt-követés szünetel</string>+ <string name="player_trakt_failed">A Trakt-követés nem sikerült</string>+ <string name="player_trakt_sent">Elküldve a Traktnak</string></resources>diff --git a/feature/playback/src/main/res/values-in/playback_player_strings.xml b/feature/playback/src/main/res/values-in/playback_player_strings.xmlindex 0177c1cd..0d9d4123 100644--- a/feature/playback/src/main/res/values-in/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-in/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Musim</string><string name="settings_recording_status_recording">Rekaman</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Hubungkan Trakt di Setelan</string>+ <string name="player_trakt_not_supported">Trakt hanya melacak film dan episode.</string>+ <string name="player_trakt_no_match">Judul ini tidak memiliki kecocokan tepat di Trakt.</string>+ <string name="player_trakt_starting">Memulai pelacakan Trakt…</string>+ <string name="player_trakt_tracking">Trakt sedang melacak pemutaran</string>+ <string name="player_trakt_paused">Pelacakan Trakt dijeda</string>+ <string name="player_trakt_failed">Pelacakan Trakt gagal</string>+ <string name="player_trakt_sent">Terkirim ke Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-it/playback_player_strings.xml b/feature/playback/src/main/res/values-it/playback_player_strings.xmlindex 338a6df9..b3072af4 100644--- a/feature/playback/src/main/res/values-it/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-it/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Stagioni</string><string name="settings_recording_status_recording">Registrazione</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Collega Trakt nelle Impostazioni</string>+ <string name="player_trakt_not_supported">Trakt monitora solo film ed episodi.</string>+ <string name="player_trakt_no_match">Nessuna corrispondenza esatta in Trakt per questo titolo.</string>+ <string name="player_trakt_starting">Avvio del monitoraggio Trakt…</string>+ <string name="player_trakt_tracking">Trakt monitora la riproduzione</string>+ <string name="player_trakt_paused">Monitoraggio Trakt in pausa</string>+ <string name="player_trakt_failed">Monitoraggio Trakt non riuscito</string>+ <string name="player_trakt_sent">Inviato a Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-iw/playback_player_strings.xml b/feature/playback/src/main/res/values-iw/playback_player_strings.xmlindex 65577eac..0b73420d 100644--- a/feature/playback/src/main/res/values-iw/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-iw/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">עונות</string><string name="settings_recording_status_recording">הקלטה</string><string name="time_range_format">%1$s עד %2$s</string>+ <string name="player_trakt_connect_required">התחברו ל‑Trakt דרך ההגדרות</string>+ <string name="player_trakt_not_supported">Trakt עוקב רק אחר סרטים ופרקים.</string>+ <string name="player_trakt_no_match">לא נמצאה התאמה מדויקת של הכותר ב‑Trakt.</string>+ <string name="player_trakt_starting">מתחיל מעקב דרך Trakt…</string>+ <string name="player_trakt_tracking">Trakt עוקב אחר ההפעלה</string>+ <string name="player_trakt_paused">המעקב דרך Trakt מושהה</string>+ <string name="player_trakt_failed">המעקב דרך Trakt נכשל</string>+ <string name="player_trakt_sent">נשלח אל Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-ja/playback_player_strings.xml b/feature/playback/src/main/res/values-ja/playback_player_strings.xmlindex 676e45f7..fd9a2961 100644--- a/feature/playback/src/main/res/values-ja/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-ja/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">シーズン</string><string name="settings_recording_status_recording">録画中</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">設定で Trakt に接続</string>+ <string name="player_trakt_not_supported">Trakt が追跡するのは映画とエピソードのみです。</string>+ <string name="player_trakt_no_match">この作品に一致する Trakt タイトルが見つかりません。</string>+ <string name="player_trakt_starting">Trakt の追跡を開始中…</string>+ <string name="player_trakt_tracking">Trakt が再生を追跡中</string>+ <string name="player_trakt_paused">Trakt の追跡を一時停止中</string>+ <string name="player_trakt_failed">Trakt の追跡に失敗しました</string>+ <string name="player_trakt_sent">Trakt に送信しました</string></resources>diff --git a/feature/playback/src/main/res/values-ko/playback_player_strings.xml b/feature/playback/src/main/res/values-ko/playback_player_strings.xmlindex 4a1ca28a..72fcaa95 100644--- a/feature/playback/src/main/res/values-ko/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-ko/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">시즌</string><string name="settings_recording_status_recording">녹화 중</string><string name="time_range_format">%1$s ~ %2$s</string>+ <string name="player_trakt_connect_required">설정에서 Trakt 연결</string>+ <string name="player_trakt_not_supported">Trakt는 영화와 에피소드만 추적합니다.</string>+ <string name="player_trakt_no_match">이 제목과 정확히 일치하는 Trakt 항목이 없습니다.</string>+ <string name="player_trakt_starting">Trakt 추적 시작 중…</string>+ <string name="player_trakt_tracking">Trakt가 재생을 추적 중입니다</string>+ <string name="player_trakt_paused">Trakt 추적이 일시 중지되었습니다</string>+ <string name="player_trakt_failed">Trakt 추적에 실패했습니다</string>+ <string name="player_trakt_sent">Trakt로 전송했습니다</string></resources>diff --git a/feature/playback/src/main/res/values-nb/playback_player_strings.xml b/feature/playback/src/main/res/values-nb/playback_player_strings.xmlindex c75c7487..f3715ed1 100644--- a/feature/playback/src/main/res/values-nb/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-nb/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Årstider</string><string name="settings_recording_status_recording">Opptak</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Koble til Trakt i Innstillinger</string>+ <string name="player_trakt_not_supported">Trakt sporer bare filmer og episoder.</string>+ <string name="player_trakt_no_match">Fant ingen nøyaktig Trakt-treff for denne tittelen.</string>+ <string name="player_trakt_starting">Starter Trakt-sporing…</string>+ <string name="player_trakt_tracking">Trakt sporer avspillingen</string>+ <string name="player_trakt_paused">Trakt-sporing er satt på pause</string>+ <string name="player_trakt_failed">Trakt-sporing mislyktes</string>+ <string name="player_trakt_sent">Sendt til Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-nl/playback_player_strings.xml b/feature/playback/src/main/res/values-nl/playback_player_strings.xmlindex ecff8ce6..20157b26 100644--- a/feature/playback/src/main/res/values-nl/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-nl/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Seizoenen</string><string name="settings_recording_status_recording">Opname</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Verbind Trakt via Instellingen</string>+ <string name="player_trakt_not_supported">Trakt volgt alleen films en afleveringen.</string>+ <string name="player_trakt_no_match">Geen exacte overeenkomst in Trakt voor deze titel.</string>+ <string name="player_trakt_starting">Trakt-tracking wordt gestart…</string>+ <string name="player_trakt_tracking">Trakt volgt de weergave</string>+ <string name="player_trakt_paused">Trakt-tracking gepauzeerd</string>+ <string name="player_trakt_failed">Trakt-tracking mislukt</string>+ <string name="player_trakt_sent">Verzonden naar Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-pl/playback_player_strings.xml b/feature/playback/src/main/res/values-pl/playback_player_strings.xmlindex 3a802388..c52295a3 100644--- a/feature/playback/src/main/res/values-pl/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-pl/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Pory roku</string><string name="settings_recording_status_recording">Nagrywanie</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Połącz Trakt w Ustawieniach</string>+ <string name="player_trakt_not_supported">Trakt śledzi tylko filmy i odcinki.</string>+ <string name="player_trakt_no_match">Nie znaleziono dokładnego dopasowania w Trakt dla tego tytułu.</string>+ <string name="player_trakt_starting">Uruchamianie śledzenia Trakt…</string>+ <string name="player_trakt_tracking">Trakt śledzi odtwarzanie</string>+ <string name="player_trakt_paused">Śledzenie Trakt wstrzymane</string>+ <string name="player_trakt_failed">Śledzenie Trakt nie powiodło się</string>+ <string name="player_trakt_sent">Wysłano do Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-pt/playback_player_strings.xml b/feature/playback/src/main/res/values-pt/playback_player_strings.xmlindex 72f82bfb..a5e9dacc 100644--- a/feature/playback/src/main/res/values-pt/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-pt/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Temporadas</string><string name="settings_recording_status_recording">Gravação</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Conecte o Trakt nas Configurações</string>+ <string name="player_trakt_not_supported">O Trakt acompanha apenas filmes e episódios.</string>+ <string name="player_trakt_no_match">Não há correspondência exata no Trakt para este título.</string>+ <string name="player_trakt_starting">Iniciando o acompanhamento do Trakt…</string>+ <string name="player_trakt_tracking">O Trakt está acompanhando a reprodução</string>+ <string name="player_trakt_paused">Acompanhamento do Trakt pausado</string>+ <string name="player_trakt_failed">Falha no acompanhamento do Trakt</string>+ <string name="player_trakt_sent">Enviado ao Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-ro/playback_player_strings.xml b/feature/playback/src/main/res/values-ro/playback_player_strings.xmlindex c529f3df..a240cabc 100644--- a/feature/playback/src/main/res/values-ro/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-ro/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">anotimpuri</string><string name="settings_recording_status_recording">Înregistrare</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Conectează Trakt din Setări</string>+ <string name="player_trakt_not_supported">Trakt urmărește doar filme și episoade.</string>+ <string name="player_trakt_no_match">Nu există o potrivire exactă în Trakt pentru acest titlu.</string>+ <string name="player_trakt_starting">Se pornește urmărirea Trakt…</string>+ <string name="player_trakt_tracking">Trakt urmărește redarea</string>+ <string name="player_trakt_paused">Urmărirea Trakt este întreruptă</string>+ <string name="player_trakt_failed">Urmărirea Trakt a eșuat</string>+ <string name="player_trakt_sent">Trimis către Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-ru/playback_player_strings.xml b/feature/playback/src/main/res/values-ru/playback_player_strings.xmlindex 70afdcc9..27e39070 100644--- a/feature/playback/src/main/res/values-ru/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-ru/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Сезоны</string><string name="settings_recording_status_recording">Запись</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Подключите Trakt в настройках</string>+ <string name="player_trakt_not_supported">Trakt отслеживает только фильмы и эпизоды.</string>+ <string name="player_trakt_no_match">Для этого названия не найдено точное совпадение в Trakt.</string>+ <string name="player_trakt_starting">Запуск отслеживания Trakt…</string>+ <string name="player_trakt_tracking">Trakt отслеживает воспроизведение</string>+ <string name="player_trakt_paused">Отслеживание Trakt приостановлено</string>+ <string name="player_trakt_failed">Не удалось выполнить отслеживание Trakt</string>+ <string name="player_trakt_sent">Отправлено в Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-sv/playback_player_strings.xml b/feature/playback/src/main/res/values-sv/playback_player_strings.xmlindex ba8bf9b0..4faa0ee2 100644--- a/feature/playback/src/main/res/values-sv/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-sv/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Årstider</string><string name="settings_recording_status_recording">Inspelning</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Anslut Trakt i Inställningar</string>+ <string name="player_trakt_not_supported">Trakt spårar bara filmer och avsnitt.</string>+ <string name="player_trakt_no_match">Ingen exakt matchning i Trakt hittades för titeln.</string>+ <string name="player_trakt_starting">Startar Trakt-spårning…</string>+ <string name="player_trakt_tracking">Trakt spårar uppspelningen</string>+ <string name="player_trakt_paused">Trakt-spårning pausad</string>+ <string name="player_trakt_failed">Trakt-spårning misslyckades</string>+ <string name="player_trakt_sent">Skickat till Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-tr/playback_player_strings.xml b/feature/playback/src/main/res/values-tr/playback_player_strings.xmlindex 6ae047ce..94e6ecd2 100644--- a/feature/playback/src/main/res/values-tr/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-tr/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Mevsimler</string><string name="settings_recording_status_recording">Kayıt</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Trakt bağlantısını Ayarlar bölümünden kurun</string>+ <string name="player_trakt_not_supported">Trakt yalnızca film ve bölümleri takip eder.</string>+ <string name="player_trakt_no_match">Bu başlık için Trakt üzerinde tam eşleşme bulunamadı.</string>+ <string name="player_trakt_starting">Trakt takibi başlatılıyor…</string>+ <string name="player_trakt_tracking">Trakt oynatmayı takip ediyor</string>+ <string name="player_trakt_paused">Trakt takibi duraklatıldı</string>+ <string name="player_trakt_failed">Trakt takibi başarısız oldu</string>+ <string name="player_trakt_sent">Trakt hizmetine gönderildi</string></resources>diff --git a/feature/playback/src/main/res/values-uk/playback_player_strings.xml b/feature/playback/src/main/res/values-uk/playback_player_strings.xmlindex f98ed44c..0ec160f7 100644--- a/feature/playback/src/main/res/values-uk/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-uk/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Сезони</string><string name="settings_recording_status_recording">Запис</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Підключіть Trakt у налаштуваннях</string>+ <string name="player_trakt_not_supported">Trakt відстежує лише фільми та епізоди.</string>+ <string name="player_trakt_no_match">Для цієї назви не знайдено точного збігу в Trakt.</string>+ <string name="player_trakt_starting">Початок відстеження Trakt…</string>+ <string name="player_trakt_tracking">Trakt відстежує відтворення</string>+ <string name="player_trakt_paused">Відстеження Trakt призупинено</string>+ <string name="player_trakt_failed">Не вдалося відстежити у Trakt</string>+ <string name="player_trakt_sent">Надіслано до Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-vi/playback_player_strings.xml b/feature/playback/src/main/res/values-vi/playback_player_strings.xmlindex 40695047..1f2c3030 100644--- a/feature/playback/src/main/res/values-vi/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-vi/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">Mùa</string><string name="settings_recording_status_recording">ghi âm</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">Kết nối Trakt trong Cài đặt</string>+ <string name="player_trakt_not_supported">Trakt chỉ theo dõi phim và tập.</string>+ <string name="player_trakt_no_match">Không tìm thấy mục Trakt khớp chính xác với tiêu đề này.</string>+ <string name="player_trakt_starting">Đang bắt đầu theo dõi bằng Trakt…</string>+ <string name="player_trakt_tracking">Trakt đang theo dõi nội dung phát</string>+ <string name="player_trakt_paused">Đã tạm dừng theo dõi Trakt</string>+ <string name="player_trakt_failed">Theo dõi Trakt thất bại</string>+ <string name="player_trakt_sent">Đã gửi đến Trakt</string></resources>diff --git a/feature/playback/src/main/res/values-zh/playback_player_strings.xml b/feature/playback/src/main/res/values-zh/playback_player_strings.xmlindex f2fdb294..d34d8c43 100644--- a/feature/playback/src/main/res/values-zh/playback_player_strings.xml+++ b/feature/playback/src/main/res/values-zh/playback_player_strings.xml@@ -196,4 +196,12 @@<string name="series_seasons">季</string><string name="settings_recording_status_recording">录制中</string><string name="time_range_format">%1$s – %2$s</string>+ <string name="player_trakt_connect_required">在设置中连接 Trakt</string>+ <string name="player_trakt_not_supported">Trakt 仅追踪电影和剧集。</string>+ <string name="player_trakt_no_match">Trakt 中没有与此标题完全匹配的条目。</string>+ <string name="player_trakt_starting">正在启动 Trakt 追踪…</string>+ <string name="player_trakt_tracking">Trakt 正在追踪播放进度</string>+ <string name="player_trakt_paused">Trakt 追踪已暂停</string>+ <string name="player_trakt_failed">Trakt 追踪失败</string>+ <string name="player_trakt_sent">已发送到 Trakt</string></resources>diff --git a/feature/playback/src/main/res/values/playback_player_strings.xml b/feature/playback/src/main/res/values/playback_player_strings.xmlindex 825a8650..696e7d7f 100644--- a/feature/playback/src/main/res/values/playback_player_strings.xml+++ b/feature/playback/src/main/res/values/playback_player_strings.xml@@ -217,6 +217,14 @@<string name="player_type_channel_number">Type channel number</string><string name="player_type_movie">Movie</string><string name="player_type_series">Series</string>+ <string name="player_trakt_connect_required">Connect Trakt in Settings</string>+ <string name="player_trakt_not_supported">Trakt tracks movies and episodes only.</string>+ <string name="player_trakt_no_match">No exact Trakt match for this title.</string>+ <string name="player_trakt_starting">Starting Trakt tracking…</string>+ <string name="player_trakt_tracking">Tracking with Trakt</string>+ <string name="player_trakt_paused">Trakt tracking paused</string>+ <string name="player_trakt_failed">Trakt tracking failed</string>+ <string name="player_trakt_sent">Sent to Trakt</string><string name="player_unmute">Unmute</string><string name="player_up_next">Up Next</string><string name="player_variants_short">Variants</string>diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTraktCoordinatorTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTraktCoordinatorTest.ktnew file mode 100644index 00000000..3351f0de--- /dev/null+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTraktCoordinatorTest.kt@@ -0,0 +1,262 @@+package com.streamvault.feature.playback.player++import com.streamvault.domain.trakt.*+import kotlinx.coroutines.CompletableDeferred+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.test.runCurrent+import kotlinx.coroutines.test.runTest+import org.junit.Assert.*+import org.junit.Test+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever+import org.mockito.kotlin.verify++@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)+class PlayerTraktCoordinatorTest {+ private val movie = TraktMediaIdentity.MovieId(603)+ private val next = TraktMediaIdentity.EpisodeId(1396, 2, 3)+ private val account = mock<TraktAccount>()+ private val state = MutableStateFlow(TraktAccountState(configured = true, connected = true))+ init { whenever(account.state).thenReturn(state) }++ @Test fun `failed start cannot create watched history on completion`() = runTest {+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ return TraktScrobbleOutcome.FAILED+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 900, 1000)+ runCurrent()+ coordinator.report(1, movie, TraktPlaybackPhase.ENDED, 1000, 1000)+ runCurrent()+ coordinator.close()+ runCurrent()+ assertEquals(listOf(TraktScrobbleAction.START), events.map { it.action })+ }++ @Test fun `turning off scrobbling pauses an active Trakt session without stopping it`() = runTest {+ val scrobbling = MutableStateFlow(true)+ val preferences = object : TraktFeaturePreferences {+ override val scrobblingEnabled = scrobbling+ override suspend fun setScrobblingEnabled(enabled: Boolean) { scrobbling.value = enabled }+ override val historySyncEnabled = MutableStateFlow(true)+ override suspend fun setHistorySyncEnabled(enabled: Boolean) = Unit+ }+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, preferences, backgroundScope)+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 500, 1000)+ runCurrent()+ scrobbling.value = false+ runCurrent()++ assertEquals(listOf(TraktScrobbleAction.START, TraktScrobbleAction.PAUSE), events.map { it.action })+ assertEquals(PlayerTraktTrackingStatus.HIDDEN, coordinator.status.value)+ coordinator.close()+ runCurrent()+ }++ @Test fun `saved account loads without first opening Trakt settings`() = runTest {+ state.value = state.value.copy(connected = false)+ whenever(account.load()).thenAnswer {+ state.value = state.value.copy(connected = true)+ Unit+ }+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ verify(account).load()+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ assertEquals(TraktScrobbleAction.START, events.single().action)+ coordinator.close()+ }++ @Test fun `unexpected tracking failure cannot kill worker or cause a retry loop`() = runTest {+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ if (events.size == 1) throw java.io.IOException("synthetic failure")+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 200, 1000)+ runCurrent()+ assertEquals(1, events.size)+ coordinator.report(2, next, TraktPlaybackPhase.PLAYING, 300, 1000)+ runCurrent()+ assertEquals(2, events.size)+ assertEquals(next, events.last().media)+ assertEquals(TraktScrobbleAction.START, events.last().action)+ coordinator.close()+ }++ @Test fun `ticks do not queue writes and switch stops at last observed progress`() = runTest {+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 10, 1000)+ runCurrent()+ repeat(500) { coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 900, 1000) }+ coordinator.report(2, next, TraktPlaybackPhase.PLAYING, 5, 1000)+ runCurrent()+ assertEquals(listOf(TraktScrobbleAction.START, TraktScrobbleAction.STOP, TraktScrobbleAction.START), events.map { it.action })+ assertEquals(90.0, events[1].progress, .001)+ coordinator.close()+ runCurrent()+ assertEquals(TraktScrobbleAction.STOP, events.last().action)+ }++ @Test fun `in flight request does not lose completion or start a stale intermediate item`() = runTest {+ val release = CompletableDeferred<Unit>()+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ if (events.size == 1) release.await()+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ coordinator.report(1, movie, TraktPlaybackPhase.ENDED, 1000, 1000)+ coordinator.report(2, next, TraktPlaybackPhase.PLAYING, 900, 1000)+ coordinator.report(3, movie, TraktPlaybackPhase.PLAYING, 0, 1000)+ release.complete(Unit)+ runCurrent()+ assertEquals(100.0, events.first { it.action == TraktScrobbleAction.STOP }.progress, .001)+ assertFalse("Skipped start must not produce a stop/history write", events.any { it.media == next })+ assertEquals(movie, events.last().media)+ assertEquals(TraktScrobbleAction.START, events.last().action)+ coordinator.close()+ }++ @Test fun `account connection during playback starts fresh while stale session is rejected`() = runTest {+ state.value = state.value.copy(connected = false)+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)+ coordinator.report(10, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ assertTrue(events.isEmpty())+ state.value = state.value.copy(connected = true)+ coordinator.report(10, movie, TraktPlaybackPhase.PLAYING, 200, 1000)+ runCurrent()+ assertEquals(1, events.size)+ coordinator.report(9, next, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ assertEquals(1, events.size)+ coordinator.close()+ }++ @Test fun `visible status confirms accepted start and pause events`() = runTest {+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent) = TraktScrobbleOutcome.SENT+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)++ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ assertEquals(PlayerTraktTrackingStatus.TRACKING, coordinator.status.value)++ coordinator.report(1, movie, TraktPlaybackPhase.PAUSED, 400, 1000)+ runCurrent()+ assertEquals(PlayerTraktTrackingStatus.PAUSED, coordinator.status.value)+ coordinator.close()+ }++ @Test fun `failed status stays visible and does not retry on position ticks`() = runTest {+ var sends = 0+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ sends+++ return TraktScrobbleOutcome.FAILED+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)++ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 500, 1000)+ runCurrent()++ assertEquals(1, sends)+ assertEquals(PlayerTraktTrackingStatus.FAILED, coordinator.status.value)+ coordinator.close()+ }++ @Test fun `live playback explains unsupported tracking without sending a scrobble`() = runTest {+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)++ coordinator.report(+ 1,+ movie,+ TraktPlaybackPhase.PLAYING,+ 100,+ 1000,+ eligibility = TraktPlaybackEligibility.LIVE,+ )+ runCurrent()++ assertTrue(events.isEmpty())+ assertEquals(PlayerTraktTrackingStatus.NOT_SUPPORTED, coordinator.status.value)+ coordinator.close()+ }++ @Test fun `start is sent when duration becomes available after playback starts`() = runTest {+ val events = mutableListOf<TraktScrobbleEvent>()+ val sender = object : TraktScrobbler {+ override suspend fun send(event: TraktScrobbleEvent): TraktScrobbleOutcome {+ events += event+ return TraktScrobbleOutcome.SENT+ }+ }+ val coordinator = PlayerTraktCoordinator(account, sender, backgroundScope)++ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 0, 0)+ runCurrent()+ coordinator.report(1, movie, TraktPlaybackPhase.PLAYING, 100, 1000)+ runCurrent()++ assertEquals(listOf(TraktScrobbleAction.START), events.map { it.action })+ assertEquals(PlayerTraktTrackingStatus.TRACKING, coordinator.status.value)+ coordinator.close()+ }+}diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTraktSupportTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTraktSupportTest.ktnew file mode 100644index 00000000..74e6dc71--- /dev/null+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTraktSupportTest.kt@@ -0,0 +1,21 @@+package com.streamvault.feature.playback.player++import com.streamvault.domain.trakt.*+import com.streamvault.player.PlaybackState+import org.junit.Assert.*+import org.junit.Test++class PlayerTraktSupportTest {+ @Test fun `engine recovery preserves session and allows playback to resume`() {+ val planner = TraktScrobblePlanner()+ val movie = TraktMediaIdentity.MovieId(603)+ fun observe(state: PlaybackState, playing: Boolean) = planner.observe(+ 1, movie, traktPlaybackPhase(state, playing), 500, 1000)+ assertEquals(TraktScrobbleAction.START, observe(PlaybackState.READY, true).single().action)+ assertTrue(observe(PlaybackState.IDLE, false).isEmpty())+ assertTrue(observe(PlaybackState.BUFFERING, false).isEmpty())+ assertEquals(TraktScrobbleAction.PAUSE, observe(PlaybackState.ERROR, false).single().action)+ assertEquals(TraktScrobbleAction.START, observe(PlaybackState.READY, true).single().action)+ assertEquals(TraktScrobbleAction.STOP, observe(PlaybackState.ENDED, false).single().action)+ }+}diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/DashboardShelfCustomizationDialog.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/DashboardShelfCustomizationDialog.ktindex e16d5d04..8d3a9c5b 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/DashboardShelfCustomizationDialog.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/DashboardShelfCustomizationDialog.kt@@ -246,6 +246,8 @@ private fun AppHomeDashboardShelf.labelResId(): Int = when (this) {AppHomeDashboardShelf.PINNED_CATEGORIES -> R.string.dashboard_pinned_categoriesAppHomeDashboardShelf.FAVORITE_MOVIES -> R.string.dashboard_favorite_moviesAppHomeDashboardShelf.FAVORITE_SERIES -> R.string.dashboard_favorite_series+ AppHomeDashboardShelf.TRAKT_WATCHLIST_MOVIES -> R.string.dashboard_trakt_watchlist_movies+ AppHomeDashboardShelf.TRAKT_WATCHLIST_SERIES -> R.string.dashboard_trakt_watchlist_seriesAppHomeDashboardShelf.CONTINUE_WATCHING_MOVIES -> R.string.dashboard_continue_watching_moviesAppHomeDashboardShelf.CONTINUE_WATCHING_SERIES -> R.string.dashboard_continue_watching_seriesAppHomeDashboardShelf.TOP_RATED_MOVIES -> R.string.dashboard_top_rated_moviesdiff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsBrowsingSection.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsBrowsingSection.ktindex 1e8265de..66b71426 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsBrowsingSection.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsBrowsingSection.kt@@ -286,6 +286,62 @@ public fun LazyListScope.settingsBrowsingSection(indent = 24.dp,modifier = if (targetItemId == "vod.portal_search") targetFocusModifier else Modifier,)+ Text(+ text = stringResource(R.string.settings_trakt_discovery_title),+ style = MaterialTheme.typography.titleSmall,+ color = OnSurface,+ modifier = Modifier.padding(top = 12.dp, bottom = 2.dp)+ )+ Text(+ text = stringResource(R.string.settings_trakt_discovery_description),+ style = MaterialTheme.typography.bodySmall,+ color = OnSurfaceDim,+ modifier = Modifier.padding(bottom = 4.dp)+ )+ SwitchSettingsRow(+ label = stringResource(R.string.settings_trakt_discovery_trending_movies),+ value = stringResource(+ if (uiState.showTraktTrendingMovies) R.string.settings_trakt_discovery_visible+ else R.string.settings_trakt_discovery_hidden+ ),+ checked = uiState.showTraktTrendingMovies,+ onCheckedChange = viewModel::setShowTraktTrendingMovies,+ indent = 24.dp,+ modifier = if (targetItemId == "vod.trakt_trending_movies") targetFocusModifier else Modifier,+ )+ SwitchSettingsRow(+ label = stringResource(R.string.settings_trakt_discovery_popular_movies),+ value = stringResource(+ if (uiState.showTraktPopularMovies) R.string.settings_trakt_discovery_visible+ else R.string.settings_trakt_discovery_hidden+ ),+ checked = uiState.showTraktPopularMovies,+ onCheckedChange = viewModel::setShowTraktPopularMovies,+ indent = 24.dp,+ modifier = if (targetItemId == "vod.trakt_popular_movies") targetFocusModifier else Modifier,+ )+ SwitchSettingsRow(+ label = stringResource(R.string.settings_trakt_discovery_trending_series),+ value = stringResource(+ if (uiState.showTraktTrendingSeries) R.string.settings_trakt_discovery_visible+ else R.string.settings_trakt_discovery_hidden+ ),+ checked = uiState.showTraktTrendingSeries,+ onCheckedChange = viewModel::setShowTraktTrendingSeries,+ indent = 24.dp,+ modifier = if (targetItemId == "vod.trakt_trending_series") targetFocusModifier else Modifier,+ )+ SwitchSettingsRow(+ label = stringResource(R.string.settings_trakt_discovery_popular_series),+ value = stringResource(+ if (uiState.showTraktPopularSeries) R.string.settings_trakt_discovery_visible+ else R.string.settings_trakt_discovery_hidden+ ),+ checked = uiState.showTraktPopularSeries,+ onCheckedChange = viewModel::setShowTraktPopularSeries,+ indent = 24.dp,+ modifier = if (targetItemId == "vod.trakt_popular_series") targetFocusModifier else Modifier,+ )}if (page == null || page == SettingsPage.VOD_ORGANIZATION) {ClickableSettingsRow(diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.ktindex fb8e079d..0c471b8d 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.kt@@ -237,6 +237,10 @@ public fun SettingsContentPane(verticalArrangement = Arrangement.spacedBy(SettingsDesignTokens.space8),userScrollEnabled = true,) {+ if (category == SettingsCategory.TRAKT) {+ item { TraktSettingsSection(modifier = if (activeSearchTarget?.itemId == "trakt.account")+ searchTargetModifier else directEntryModifier) }+ }if (page == null && category.pages.isNotEmpty()) {items(category.pages, key = { it.name }) { destination ->val isReturnTarget = destination == lastPagediff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.ktindex b7cdc43d..386c35c8 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.kt@@ -13,7 +13,8 @@ enum class SettingsCategory(val legacyId: Int, val title: Int, val description:RECORDING(4, R.string.settings_recording_title, R.string.settings_recording_description),BACKUP(5, R.string.settings_backup_restore, R.string.settings_backup_description),GUIDE(6, R.string.settings_domain_guide, R.string.settings_guide_description),- ABOUT(7, R.string.settings_about, R.string.settings_about_description);+ ABOUT(7, R.string.settings_about, R.string.settings_about_description),+ TRAKT(10, R.string.settings_trakt, R.string.settings_trakt_description);val pages: List<SettingsPage> get() = SettingsPage.entries.filter { it.categoryId == legacyId }companion object {diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsNavigationRail.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsNavigationRail.ktindex 703ebfb6..d1a1c7f7 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsNavigationRail.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsNavigationRail.kt@@ -44,6 +44,7 @@ internal val SettingsCategory.icon: ImageVector get() = when (this) {SettingsCategory.BACKUP -> Icons.Rounded.CloudUploadSettingsCategory.GUIDE -> Icons.Rounded.CalendarMonthSettingsCategory.ABOUT -> Icons.Rounded.Info+ SettingsCategory.TRAKT -> Icons.Rounded.AccountCircle}@Composablediff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceModels.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceModels.ktindex 1a8d05d8..942d4d3c 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceModels.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceModels.kt@@ -119,6 +119,10 @@ data class SettingsPreferenceSnapshot(val groupedChannelLabelMode: GroupedChannelLabelMode,val liveVariantPreferenceMode: LiveVariantPreferenceMode,val vodViewMode: VodViewMode,+ val showTraktTrendingMovies: Boolean = true,+ val showTraktPopularMovies: Boolean = true,+ val showTraktTrendingSeries: Boolean = true,+ val showTraktPopularSeries: Boolean = true,val vodTypeBadgeAsIcon: Boolean,val vodCategoryLoadMode: VodCategoryLoadMode,val vodInfiniteScroll: Boolean,diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceSnapshotMapper.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceSnapshotMapper.ktindex 4d0cb3b5..05189322 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceSnapshotMapper.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsPreferenceSnapshotMapper.kt@@ -81,6 +81,10 @@ fun SettingsUiState.applyPreferenceSnapshot(groupedChannelLabelMode = snapshot.groupedChannelLabelMode,liveVariantPreferenceMode = snapshot.liveVariantPreferenceMode,vodViewMode = snapshot.vodViewMode,+ showTraktTrendingMovies = snapshot.showTraktTrendingMovies,+ showTraktPopularMovies = snapshot.showTraktPopularMovies,+ showTraktTrendingSeries = snapshot.showTraktTrendingSeries,+ showTraktPopularSeries = snapshot.showTraktPopularSeries,vodTypeBadgeAsIcon = snapshot.vodTypeBadgeAsIcon,vodCategoryLoadMode = snapshot.vodCategoryLoadMode,vodInfiniteScroll = snapshot.vodInfiniteScroll,diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsSearchSurface.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsSearchSurface.ktindex 58cd8995..4133e2fb 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsSearchSurface.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsSearchSurface.kt@@ -270,6 +270,10 @@ private fun resolvedSettingsCatalog(setting("live.multiview_center_two", SettingsCategory.LIVE_TV, SettingsPage.MULTIVIEW, R.string.settings_multiview_center_two_slot_layout),setting("live.multiview_connection_limit", SettingsCategory.LIVE_TV, SettingsPage.MULTIVIEW, R.string.settings_multiview_respect_provider_connection_limit),setting("vod.view_mode", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_vod_view_mode, "library layout"),+ setting("vod.trakt_trending_movies", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_trakt_discovery_trending_movies, "trakt"),+ setting("vod.trakt_popular_movies", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_trakt_discovery_popular_movies, "trakt"),+ setting("vod.trakt_trending_series", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_trakt_discovery_trending_series, "trakt"),+ setting("vod.trakt_popular_series", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_trakt_discovery_popular_series, "trakt"),setting("vod.type_badge_icon", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_vod_type_badge_icons),setting("vod.complete_on_open", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_vod_complete_on_open, "loading"),setting("vod.infinite_scroll", SettingsCategory.MOVIES, SettingsPage.VOD_LIBRARY, R.string.settings_vod_infinite_scroll),@@ -298,6 +302,7 @@ private fun resolvedSettingsCatalog(remoteSetting(RemoteShortcutProfile.BROWSE, R.string.settings_remote_profile_browse, RemoteColorButton.GREEN, R.string.settings_remote_button_green),remoteSetting(RemoteShortcutProfile.BROWSE, R.string.settings_remote_profile_browse, RemoteColorButton.YELLOW, R.string.settings_remote_button_yellow),remoteSetting(RemoteShortcutProfile.BROWSE, R.string.settings_remote_profile_browse, RemoteColorButton.BLUE, R.string.settings_remote_button_blue),+ setting("trakt.account", SettingsCategory.TRAKT, null, R.string.settings_trakt, "account", "connect", "scrobble"),setting("privacy.incognito", SettingsCategory.PRIVACY, null, R.string.settings_incognito_mode, "private viewing", "history"),setting("privacy.clear_history", SettingsCategory.PRIVACY, null, R.string.settings_clear_history, "watch progress", "recents"),setting("privacy.protection_level", SettingsCategory.PRIVACY, null, R.string.settings_protection_level, "parental controls", "lock"),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.ktindex 57ac462a..67863a02 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@@ -114,6 +114,10 @@ fun observeSettingsPreferenceSnapshot(groupedChannelLabelMode = GroupedChannelLabelMode.HYBRID,liveVariantPreferenceMode = LiveVariantPreferenceMode.BALANCED,vodViewMode = VodViewMode.MODERN,+ showTraktTrendingMovies = true,+ showTraktPopularMovies = true,+ showTraktTrendingSeries = true,+ showTraktPopularSeries = true,vodTypeBadgeAsIcon = false,vodCategoryLoadMode = VodCategoryLoadMode.PAGED,vodInfiniteScroll = true,@@ -271,6 +275,14 @@ fun observeSettingsPreferenceSnapshot(snapshot.copy(liveVariantPreferenceMode = liveVariantPreferenceMode)}.combine(preferencesRepository.vodViewMode) { snapshot, vodViewMode ->snapshot.copy(vodViewMode = VodViewMode.fromStorage(vodViewMode))+ }.combine(preferencesRepository.showTraktTrendingMovies) { snapshot, enabled ->+ snapshot.copy(showTraktTrendingMovies = enabled)+ }.combine(preferencesRepository.showTraktPopularMovies) { snapshot, enabled ->+ snapshot.copy(showTraktPopularMovies = enabled)+ }.combine(preferencesRepository.showTraktTrendingSeries) { snapshot, enabled ->+ snapshot.copy(showTraktTrendingSeries = enabled)+ }.combine(preferencesRepository.showTraktPopularSeries) { snapshot, enabled ->+ snapshot.copy(showTraktPopularSeries = enabled)}.combine(preferencesRepository.vodTypeBadgeAsIcon) { snapshot, vodTypeBadgeAsIcon ->snapshot.copy(vodTypeBadgeAsIcon = vodTypeBadgeAsIcon)}.combine(preferencesRepository.vodCategoryLoadMode) { snapshot, vodCategoryLoadMode ->diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsUiStateModel.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsUiStateModel.ktindex 1651f19e..93b3bae4 100644--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsUiStateModel.kt+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsUiStateModel.kt@@ -171,6 +171,10 @@ data class SettingsUiState(val groupedChannelLabelMode: GroupedChannelLabelMode = GroupedChannelLabelMode.HYBRID,val liveVariantPreferenceMode: LiveVariantPreferenceMode = LiveVariantPreferenceMode.BALANCED,val vodViewMode: VodViewMode = VodViewMode.MODERN,+ val showTraktTrendingMovies: Boolean = true,+ val showTraktPopularMovies: Boolean = true,+ val showTraktTrendingSeries: Boolean = true,+ val showTraktPopularSeries: Boolean = true,val vodTypeBadgeAsIcon: Boolean = false,val vodCategoryLoadMode: VodCategoryLoadMode = VodCategoryLoadMode.PAGED,val vodInfiniteScroll: Boolean = true,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.ktindex 38331ff9..9ddd0aae 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@@ -625,6 +625,22 @@ class SettingsViewModel @Inject constructor(}}+ fun setShowTraktTrendingMovies(enabled: Boolean) {+ viewModelScope.launch { preferencesRepository.setShowTraktTrendingMovies(enabled) }+ }++ fun setShowTraktPopularMovies(enabled: Boolean) {+ viewModelScope.launch { preferencesRepository.setShowTraktPopularMovies(enabled) }+ }++ fun setShowTraktTrendingSeries(enabled: Boolean) {+ viewModelScope.launch { preferencesRepository.setShowTraktTrendingSeries(enabled) }+ }++ fun setShowTraktPopularSeries(enabled: Boolean) {+ viewModelScope.launch { preferencesRepository.setShowTraktPopularSeries(enabled) }+ }+fun setVodTypeBadgeAsIcon(enabled: Boolean) {viewModelScope.launch {preferencesRepository.setVodTypeBadgeAsIcon(enabled)diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/TraktCustomListsSettings.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/TraktCustomListsSettings.ktnew file mode 100644index 00000000..623bec99--- /dev/null+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/TraktCustomListsSettings.kt@@ -0,0 +1,434 @@+package com.streamvault.feature.settings.presentation++import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.layout.widthIn+import androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.material3.AlertDialog+import androidx.compose.material3.TextButton+import androidx.compose.runtime.Composable+import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.collectAsState+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue+import androidx.compose.ui.Modifier+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.unit.dp+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel+import androidx.lifecycle.ViewModel+import androidx.lifecycle.viewModelScope+import androidx.tv.material3.Button+import androidx.tv.material3.ButtonDefaults+import androidx.tv.material3.Surface+import androidx.tv.material3.SurfaceDefaults+import androidx.tv.material3.Text+import com.streamvault.core.ui.design.AppColors+import com.streamvault.core.ui.components.TvOutlinedTextField+import com.streamvault.domain.trakt.TraktCustomList+import com.streamvault.domain.trakt.TraktCustomListActionResult+import com.streamvault.domain.trakt.TraktCustomListItemsRefreshResult+import com.streamvault.domain.trakt.TraktCustomListRefreshResult+import com.streamvault.domain.trakt.TraktCustomLists+import com.streamvault.domain.trakt.TraktCustomListsFailure+import com.streamvault.domain.trakt.TraktCustomListsState+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.feature.settings.R+import dagger.hilt.android.lifecycle.HiltViewModel+import javax.inject.Inject+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.launch++@HiltViewModel+class TraktCustomListsSettingsViewModel @Inject constructor(+ private val customLists: TraktCustomLists,+ private val account: TraktAccount,+) : ViewModel() {+ val state = customLists.state+ val accountState = account.state+ private val mutableBusy = MutableStateFlow(false)+ val busy = mutableBusy.asStateFlow()+ private val mutableFailure = MutableStateFlow<TraktCustomListsFailure?>(null)+ val failure = mutableFailure.asStateFlow()++ fun refresh() = perform {+ when (val result = customLists.refreshLists(force = true)) {+ is TraktCustomListRefreshResult.Success -> Unit+ is TraktCustomListRefreshResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun refreshIfAccountChanged(username: String?, connected: Boolean) {+ if (!connected || username.isNullOrBlank()) return+ viewModelScope.launch {+ mutableBusy.first { !it }+ val currentAccount = account.state.value+ val currentLists = customLists.state.value+ if (currentAccount.connected && currentAccount.username == username &&+ (!currentLists.listsLoaded || currentLists.accountUsername != username)+ ) {+ refresh()+ }+ }+ }++ fun openList(listId: Long) = perform {+ when (val result = customLists.refreshItems(listId, force = true)) {+ is TraktCustomListItemsRefreshResult.Success -> Unit+ is TraktCustomListItemsRefreshResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun create(name: String, description: String) = perform {+ when (val result = customLists.createList(name, description.takeIf(String::isNotBlank))) {+ TraktCustomListActionResult.Success -> Unit+ is TraktCustomListActionResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun remove(listId: Long, item: com.streamvault.domain.trakt.TraktCustomListItem) = perform {+ when (val result = customLists.setItem(listId, item, included = false)) {+ TraktCustomListActionResult.Success -> Unit+ is TraktCustomListActionResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun deleteList(listId: Long) = perform {+ when (val result = customLists.deleteList(listId)) {+ TraktCustomListActionResult.Success -> Unit+ is TraktCustomListActionResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun moveList(listId: Long, direction: Int) = perform {+ val current = state.value.lists+ val from = current.indexOfFirst { it.id == listId }+ val to = from + direction+ if (from < 0 || to !in current.indices) return@perform+ val reordered = current.toMutableList().apply {+ add(to, removeAt(from))+ }+ when (val result = customLists.reorderLists(reordered.map { it.id })) {+ TraktCustomListActionResult.Success -> Unit+ is TraktCustomListActionResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun moveItem(listId: Long, item: com.streamvault.domain.trakt.TraktCustomListItem, direction: Int) = perform {+ val current = state.value.itemsByList[listId].orEmpty()+ val from = current.indexOfFirst { it.identity == item.identity }+ val to = from + direction+ if (from < 0 || to !in current.indices) return@perform+ val reordered = current.toMutableList().apply { add(to, removeAt(from)) }+ when (val result = customLists.reorderItems(listId, reordered)) {+ TraktCustomListActionResult.Success -> Unit+ is TraktCustomListActionResult.Failure -> mutableFailure.value = result.reason+ }+ }++ fun clearFailure() {+ mutableFailure.value = null+ }++ private fun perform(action: suspend () -> Unit) {+ if (mutableBusy.value) return+ viewModelScope.launch {+ mutableBusy.value = true+ mutableFailure.value = null+ try { action() } finally { mutableBusy.value = false }+ }+ }+}++@Composable+internal fun TraktCustomListsSettings() {+ val viewModel: TraktCustomListsSettingsViewModel = hiltViewModel()+ val state by viewModel.state.collectAsState()+ val accountState by viewModel.accountState.collectAsState()+ val busy by viewModel.busy.collectAsState()+ val failure by viewModel.failure.collectAsState()+ var selectedListId by remember { mutableStateOf<Long?>(null) }+ var createExpanded by remember { mutableStateOf(false) }+ var listName by remember { mutableStateOf("") }+ var listDescription by remember { mutableStateOf("") }+ var deleteConfirmation by remember { mutableStateOf<TraktCustomList?>(null) }++ LaunchedEffect(accountState.connected, accountState.username) {+ viewModel.refreshIfAccountChanged(accountState.username, accountState.connected)+ }+ LaunchedEffect(state.failure) {+ if (state.failure == null) viewModel.clearFailure()+ }++ Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {+ Text(stringResource(R.string.trakt_custom_lists_title), color = AppColors.TextPrimary)+ Text(stringResource(R.string.trakt_custom_lists_description), color = AppColors.TextSecondary)+ Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {+ Button(+ onClick = viewModel::refresh,+ enabled = !busy,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis.copy(alpha = 0.6f),+ disabledContentColor = AppColors.TextSecondary,+ ),+ ) {+ Text(stringResource(R.string.trakt_custom_lists_refresh))+ }+ Button(+ onClick = { createExpanded = !createExpanded },+ enabled = !busy,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis.copy(alpha = 0.6f),+ disabledContentColor = AppColors.TextSecondary,+ ),+ ) {+ Text(stringResource(if (createExpanded) R.string.settings_cancel else R.string.trakt_custom_lists_create))+ }+ }++ if (createExpanded) {+ Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {+ TvOutlinedTextField(+ value = listName,+ onValueChange = { listName = it },+ label = {+ Text(+ stringResource(R.string.trakt_custom_lists_name),+ color = AppColors.TextSecondary,+ )+ },+ singleLine = true,+ enabled = !busy,+ modifier = Modifier.widthIn(max = 520.dp),+ colors = { containerFocused -> traktListTextFieldColors(containerFocused) },+ )+ TvOutlinedTextField(+ value = listDescription,+ onValueChange = { listDescription = it },+ label = {+ Text(+ stringResource(R.string.trakt_custom_lists_optional_description),+ color = AppColors.TextSecondary,+ )+ },+ minLines = 2,+ maxLines = 3,+ enabled = !busy,+ modifier = Modifier.widthIn(max = 520.dp),+ colors = { containerFocused -> traktListTextFieldColors(containerFocused) },+ )+ Text(stringResource(R.string.trakt_custom_lists_private_note), color = AppColors.TextSecondary)+ Button(+ onClick = {+ viewModel.create(listName, listDescription)+ listName = ""+ listDescription = ""+ createExpanded = false+ },+ enabled = !busy && listName.isNotBlank(),+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Brand,+ contentColor = AppColors.OnPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis,+ disabledContentColor = AppColors.TextSecondary,+ ),+ ) { Text(stringResource(R.string.trakt_custom_lists_create)) }+ }+ }++ when {+ !state.listsLoaded -> Text(+ stringResource(if (busy || state.refreshingLists) R.string.trakt_custom_lists_loading+ else R.string.trakt_custom_lists_not_loaded),+ color = AppColors.TextSecondary,+ )+ state.lists.isEmpty() -> Text(stringResource(R.string.trakt_custom_lists_empty), color = AppColors.TextSecondary)+ else -> state.lists.forEachIndexed { index, list ->+ CustomListRow(+ list = list,+ expanded = selectedListId == list.id,+ state = state,+ busy = busy,+ onClick = {+ if (selectedListId == list.id) {+ selectedListId = null+ } else {+ selectedListId = list.id+ viewModel.openList(list.id)+ }+ },+ onRemove = { item -> viewModel.remove(list.id, item) },+ onDelete = { deleteConfirmation = list },+ canMoveUp = index > 0,+ canMoveDown = index < state.lists.lastIndex,+ onMoveUp = { viewModel.moveList(list.id, -1) },+ onMoveDown = { viewModel.moveList(list.id, 1) },+ onMoveItemUp = { item -> viewModel.moveItem(list.id, item, -1) },+ onMoveItemDown = { item -> viewModel.moveItem(list.id, item, 1) },+ )+ }+ }++ if (failure != null) {+ Text(+ stringResource(when (failure) {+ TraktCustomListsFailure.DISCONNECTED -> R.string.trakt_custom_lists_connect_first+ TraktCustomListsFailure.INCOGNITO -> R.string.trakt_custom_lists_incognito+ TraktCustomListsFailure.READ_LIMIT -> R.string.trakt_custom_lists_too_large+ else -> R.string.trakt_custom_lists_failed+ }),+ color = AppColors.Warning,+ )+ }+ }++ deleteConfirmation?.let { list ->+ AlertDialog(+ onDismissRequest = { if (!busy) deleteConfirmation = null },+ title = { Text(stringResource(R.string.trakt_custom_lists_delete_title)) },+ text = { Text(stringResource(R.string.trakt_custom_lists_delete_message, list.name)) },+ confirmButton = {+ TextButton(+ enabled = !busy,+ onClick = {+ viewModel.deleteList(list.id)+ deleteConfirmation = null+ if (selectedListId == list.id) selectedListId = null+ },+ ) { Text(stringResource(R.string.trakt_custom_lists_delete)) }+ },+ dismissButton = {+ TextButton(enabled = !busy, onClick = { deleteConfirmation = null }) {+ Text(stringResource(R.string.settings_cancel))+ }+ },+ )+ }+}++@Composable+private fun CustomListRow(+ list: TraktCustomList,+ expanded: Boolean,+ state: TraktCustomListsState,+ busy: Boolean,+ onClick: () -> Unit,+ onRemove: (com.streamvault.domain.trakt.TraktCustomListItem) -> Unit,+ onDelete: () -> Unit,+ canMoveUp: Boolean,+ canMoveDown: Boolean,+ onMoveUp: () -> Unit,+ onMoveDown: () -> Unit,+ onMoveItemUp: (com.streamvault.domain.trakt.TraktCustomListItem) -> Unit,+ onMoveItemDown: (com.streamvault.domain.trakt.TraktCustomListItem) -> Unit,+) {+ Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {+ Button(+ onClick = onClick,+ enabled = !busy,+ modifier = Modifier.weight(1f),+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ ),+ ) {+ Text(stringResource(R.string.trakt_custom_list_open_with_privacy,+ list.name, list.itemCount, list.privacy))+ }+ Button(onClick = onMoveUp, enabled = !busy && canMoveUp, colors = traktListManageButtonColors()) {+ Text(stringResource(R.string.trakt_custom_lists_move_up))+ }+ Button(onClick = onMoveDown, enabled = !busy && canMoveDown, colors = traktListManageButtonColors()) {+ Text(stringResource(R.string.trakt_custom_lists_move_down))+ }+ Button(onClick = onDelete, enabled = !busy, colors = traktListManageButtonColors()) {+ Text(stringResource(R.string.trakt_custom_lists_delete))+ }+ }+ if (!expanded) return+ if (list.id in state.loadingItems) {+ Text(stringResource(R.string.trakt_custom_lists_loading), color = AppColors.TextSecondary)+ } else if (state.itemsLoaded(list.id)) {+ val items = state.itemsByList[list.id].orEmpty()+ val canReorderItems = items.isNotEmpty() && items.all { it.listItemId != null } &&+ items.mapNotNull { it.listItemId }.distinct().size == items.size+ if (items.isEmpty()) {+ Text(stringResource(R.string.trakt_custom_lists_no_items), color = AppColors.TextSecondary)+ } else {+ items.take(200).forEachIndexed { index, item ->+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ Text(+ text = listOfNotNull(item.title, item.year?.toString()).joinToString(" · "),+ color = AppColors.TextPrimary,+ modifier = Modifier.weight(1f),+ )+ if (canReorderItems) {+ Button(+ onClick = { onMoveItemUp(item) },+ enabled = !busy && index > 0,+ colors = traktListManageButtonColors(),+ ) { Text(stringResource(R.string.trakt_custom_lists_move_up)) }+ Button(+ onClick = { onMoveItemDown(item) },+ enabled = !busy && index < items.lastIndex,+ colors = traktListManageButtonColors(),+ ) { Text(stringResource(R.string.trakt_custom_lists_move_down)) }+ }+ Button(+ onClick = { onRemove(item) },+ enabled = !busy,+ colors = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis.copy(alpha = 0.6f),+ disabledContentColor = AppColors.TextSecondary,+ ),+ ) {+ Text(stringResource(R.string.trakt_custom_list_remove_item))+ }+ }+ }+ if (items.size > 200) Text(+ stringResource(R.string.trakt_custom_list_items_truncated),+ color = AppColors.TextSecondary,+ )+ }+ }+ }+}++@Composable+private fun traktListManageButtonColors() = ButtonDefaults.colors(+ containerColor = AppColors.SurfaceEmphasis,+ contentColor = AppColors.TextPrimary,+ disabledContainerColor = AppColors.SurfaceEmphasis.copy(alpha = 0.5f),+ disabledContentColor = AppColors.TextTertiary,+)++@Composable+private fun traktListTextFieldColors(containerFocused: Boolean) = androidx.compose.material3.OutlinedTextFieldDefaults.colors(+ focusedTextColor = AppColors.TextPrimary,+ unfocusedTextColor = AppColors.TextPrimary,+ disabledTextColor = AppColors.TextDisabled,+ cursorColor = AppColors.Brand,+ focusedBorderColor = AppColors.Brand,+ unfocusedBorderColor = if (containerFocused) AppColors.Brand else AppColors.Outline,+ disabledBorderColor = AppColors.Outline.copy(alpha = 0.5f),+ focusedLabelColor = AppColors.Brand,+ unfocusedLabelColor = AppColors.TextSecondary,+ disabledLabelColor = AppColors.TextTertiary,+ focusedContainerColor = AppColors.Surface,+ unfocusedContainerColor = AppColors.Surface,+ disabledContainerColor = AppColors.Surface,+)diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/TraktSettingsSection.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/TraktSettingsSection.ktnew file mode 100644index 00000000..3105cbc2--- /dev/null+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/TraktSettingsSection.kt@@ -0,0 +1,213 @@+package com.streamvault.feature.settings.presentation++import android.content.ActivityNotFoundException+import android.content.Intent+import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.focusable+import androidx.compose.runtime.Composable+import androidx.compose.runtime.getValue+import androidx.compose.ui.platform.LocalContext+import androidx.compose.ui.Modifier+import androidx.compose.ui.res.pluralStringResource+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.unit.dp+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel+import androidx.lifecycle.ViewModel+import androidx.lifecycle.compose.collectAsStateWithLifecycle+import androidx.lifecycle.viewModelScope+import androidx.core.net.toUri+import androidx.tv.material3.Button+import androidx.tv.material3.Text+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktMessage+import com.streamvault.domain.trakt.TraktHistorySync+import com.streamvault.domain.trakt.TraktHistorySyncResult+import com.streamvault.domain.trakt.TraktSyncFailure+import com.streamvault.domain.trakt.TraktFeaturePreferences+import com.streamvault.domain.trakt.TraktFavoriteImporter+import com.streamvault.domain.trakt.TraktFavoriteImportResult+import com.streamvault.domain.trakt.TraktFavoriteFailure+import com.streamvault.feature.settings.R+import com.streamvault.core.ui.design.AppColors+import dagger.hilt.android.lifecycle.HiltViewModel+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.flow.SharingStarted+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.flow.stateIn+import kotlinx.coroutines.launch+import javax.inject.Inject++@HiltViewModel+class TraktSettingsViewModel @Inject constructor(private val account: TraktAccount,+ private val historySync: TraktHistorySync,+ private val preferences: TraktFeaturePreferences,+ private val favoriteImporter: TraktFavoriteImporter) : ViewModel() {+ val state = account.state+ val scrobblingEnabled = preferences.scrobblingEnabled.stateIn(viewModelScope, SharingStarted.Eagerly, true)+ val historySyncEnabled = preferences.historySyncEnabled.stateIn(viewModelScope, SharingStarted.Eagerly, true)+ private val mutableBusy = MutableStateFlow(false)+ val busy = mutableBusy.asStateFlow()+ private val mutableFailed = MutableStateFlow(false)+ val failed = mutableFailed.asStateFlow()+ private val mutableBrowserUnavailable = MutableStateFlow(false)+ val browserUnavailable = mutableBrowserUnavailable.asStateFlow()+ private val mutableSyncResult = MutableStateFlow<TraktHistorySyncResult?>(null)+ val syncResult = mutableSyncResult.asStateFlow()+ private val mutableFavoriteImportResult = MutableStateFlow<TraktFavoriteImportResult?>(null)+ val favoriteImportResult = mutableFavoriteImportResult.asStateFlow()+ init { perform { account.load() } }+ fun connect(openBrowser: (String) -> Unit) = perform {+ mutableSyncResult.value = null+ mutableFavoriteImportResult.value = null+ val url = account.beginSignIn()+ try { openBrowser(url) } catch (failure: Exception) {+ account.cancelSignIn()+ if (failure is ActivityNotFoundException) mutableBrowserUnavailable.value = true+ else throw failure+ }+ }+ fun cancel() = perform { account.cancelSignIn() }+ fun disconnect() = perform {+ mutableSyncResult.value = null+ mutableFavoriteImportResult.value = null+ account.disconnect()+ }+ fun profile() = perform { account.refreshProfile() }+ fun setScrobblingEnabled(enabled: Boolean) {+ viewModelScope.launch { preferences.setScrobblingEnabled(enabled) }+ }+ fun setHistorySyncEnabled(enabled: Boolean) {+ viewModelScope.launch { preferences.setHistorySyncEnabled(enabled) }+ }+ fun syncHistory() = perform {+ mutableSyncResult.value = null+ if (preferences.historySyncEnabled.first()) mutableSyncResult.value = historySync.sync()+ }+ fun importFavorites() = perform {+ mutableFavoriteImportResult.value = favoriteImporter.importToLocal()+ }+ private fun perform(action: suspend () -> Unit) {+ if (mutableBusy.value) return+ mutableBusy.value = true+ mutableFailed.value = false+ mutableBrowserUnavailable.value = false+ viewModelScope.launch {+ try { action() } catch (failure: Exception) {+ if (failure is CancellationException) throw failure+ mutableFailed.value = true+ } finally { mutableBusy.value = false }+ }+ }+}++@Composable+internal fun TraktSettingsSection(modifier: Modifier = Modifier, viewModel: TraktSettingsViewModel = hiltViewModel()) {+ val state by viewModel.state.collectAsStateWithLifecycle()+ val busy by viewModel.busy.collectAsStateWithLifecycle()+ val failed by viewModel.failed.collectAsStateWithLifecycle()+ val browserUnavailable by viewModel.browserUnavailable.collectAsStateWithLifecycle()+ val syncResult by viewModel.syncResult.collectAsStateWithLifecycle()+ val favoriteImportResult by viewModel.favoriteImportResult.collectAsStateWithLifecycle()+ val scrobblingEnabled by viewModel.scrobblingEnabled.collectAsStateWithLifecycle()+ val historySyncEnabled by viewModel.historySyncEnabled.collectAsStateWithLifecycle()+ val context = LocalContext.current+ val colors = SettingsDesignTokens.colors(AppColors.current)+ Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {+ Text(stringResource(if (state.connected) R.string.trakt_connected else R.string.trakt_disconnected),+ color = colors.primaryText,+ modifier = if (!state.configured && !state.connected) modifier.focusable() else Modifier)+ state.username?.let { Text(it, color = colors.primaryText) }+ state.profile?.let { profile ->+ profile.name?.let { Text(stringResource(R.string.trakt_profile_name, it), color = colors.secondaryText) }+ profile.location?.let { Text(stringResource(R.string.trakt_profile_location, it), color = colors.secondaryText) }+ profile.joinedAt?.let { Text(stringResource(R.string.trakt_profile_joined, it.take(10)), color = colors.secondaryText) }+ profile.gender?.let { Text(stringResource(R.string.trakt_profile_gender, it), color = colors.secondaryText) }+ profile.age?.let { Text(stringResource(R.string.trakt_profile_age, it), color = colors.secondaryText) }+ if (profile.vip) Text(stringResource(R.string.trakt_profile_vip), color = colors.secondaryText)+ profile.about?.let { Text(stringResource(R.string.trakt_profile_about, it), color = colors.secondaryText) }+ }+ if (!state.configured) Text(stringResource(R.string.trakt_configuration_required), color = colors.secondaryText)+ val message = when (state.message) {+ TraktMessage.CONFIGURATION_REQUIRED -> R.string.trakt_configuration_required+ TraktMessage.RECONNECT_REQUIRED -> R.string.trakt_reconnect_required+ TraktMessage.RATE_LIMITED -> R.string.trakt_rate_limited+ TraktMessage.NETWORK_ERROR -> R.string.trakt_network_error+ TraktMessage.SIGN_IN_FAILED -> R.string.trakt_sign_in_failed+ null -> null+ }+ message?.let { Text(stringResource(it), color = colors.error) }+ if (failed) Text(stringResource(R.string.trakt_sign_in_failed), color = colors.error)+ if (browserUnavailable) Text(stringResource(R.string.trakt_browser_required), color = colors.secondaryText)+ if (state.connected) {+ Button(onClick = viewModel::profile, modifier = modifier, enabled = !busy) { Text(stringResource(R.string.trakt_refresh_profile)) }+ SwitchSettingsRow(+ label = stringResource(R.string.trakt_scrobbling_setting),+ value = stringResource(if (scrobblingEnabled) R.string.trakt_setting_enabled else R.string.trakt_setting_disabled),+ checked = scrobblingEnabled,+ onCheckedChange = viewModel::setScrobblingEnabled,+ enabled = !busy,+ )+ SwitchSettingsRow(+ label = stringResource(R.string.trakt_history_sync_setting),+ value = stringResource(if (historySyncEnabled) R.string.trakt_setting_enabled else R.string.trakt_setting_disabled),+ checked = historySyncEnabled,+ onCheckedChange = viewModel::setHistorySyncEnabled,+ enabled = !busy,+ )+ Text(stringResource(R.string.trakt_sync_description), color = colors.secondaryText)+ Button(onClick = viewModel::syncHistory, enabled = !busy && historySyncEnabled) { Text(stringResource(R.string.trakt_sync_now)) }+ when (val result = syncResult) {+ is TraktHistorySyncResult.Success -> Text(stringResource(R.string.trakt_sync_complete,+ result.imported, result.uploaded, result.unchanged, result.unmatched, result.skipped), color = colors.secondaryText)+ is TraktHistorySyncResult.Failure -> Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {+ Text(stringResource(when (result.reason) {+ TraktSyncFailure.READ_LIMIT -> R.string.trakt_sync_limit+ TraktSyncFailure.INCOGNITO -> R.string.trakt_sync_incognito+ else -> R.string.trakt_sync_failed+ }), color = colors.error)+ if (result.imported > 0) Text(pluralStringResource(+ R.plurals.trakt_sync_imported_count, result.imported, result.imported), color = colors.secondaryText)+ }+ null -> Unit+ }+ if ((syncResult as? TraktHistorySyncResult.Success)?.moreUploads == true) {+ Text(stringResource(R.string.trakt_sync_more_uploads), color = colors.secondaryText)+ }+ Button(onClick = viewModel::importFavorites, enabled = !busy) {+ Text(stringResource(R.string.trakt_import_favorites))+ }+ when (val result = favoriteImportResult) {+ is TraktFavoriteImportResult.Success -> Text(+ stringResource(R.string.trakt_import_favorites_result,+ result.imported, result.alreadyPresent, result.unmatched, result.skipped),+ color = colors.secondaryText,+ )+ is TraktFavoriteImportResult.Failure -> Text(+ stringResource(when (result.reason) {+ TraktFavoriteFailure.DISCONNECTED -> R.string.trakt_favorites_connect_first+ TraktFavoriteFailure.INCOGNITO -> R.string.trakt_favorites_incognito+ TraktFavoriteFailure.NO_ACTIVE_PROVIDER -> R.string.trakt_favorites_provider_required+ TraktFavoriteFailure.READ_LIMIT -> R.string.trakt_favorites_too_large+ else -> R.string.trakt_favorites_import_failed+ }, result.imported),+ color = colors.error,+ )+ null -> Unit+ }+ Button(onClick = viewModel::disconnect, enabled = !busy) { Text(stringResource(R.string.trakt_disconnect)) }+ TraktCustomListsSettings()+ } else {+ Button(onClick = {+ viewModel.connect { url -> context.startActivity(Intent(Intent.ACTION_VIEW, url.toUri())) }+ }, modifier = if (state.configured && !state.connecting) modifier else Modifier,+ enabled = state.configured && !busy && !state.connecting) { Text(stringResource(R.string.trakt_connect)) }+ if (state.connecting) {+ Text(stringResource(R.string.trakt_complete_browser), color = colors.secondaryText)+ Button(onClick = viewModel::cancel, modifier = modifier, enabled = !busy) { Text(stringResource(R.string.trakt_cancel)) }+ }+ }+ }+}diff --git a/feature/settings/src/main/res/values-ar/strings.xml b/feature/settings/src/main/res/values-ar/strings.xmlindex bd7e3983..28230469 100644--- a/feature/settings/src/main/res/values-ar/strings.xml+++ b/feature/settings/src/main/res/values-ar/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">بدّل مصادر IPTV الخاصة بك، وزامنها، وعدّلها، واستكشف أخطاءها.</string><string name="settings_title">الإعدادات</string>+<string name="dashboard_trakt_watchlist_movies">قائمة Trakt للأفلام</string>+<string name="dashboard_trakt_watchlist_series">قائمة Trakt للمسلسلات</string></resources>diff --git a/feature/settings/src/main/res/values-cs/strings.xml b/feature/settings/src/main/res/values-cs/strings.xmlindex 943f608e..a2b8ead4 100644--- a/feature/settings/src/main/res/values-cs/strings.xml+++ b/feature/settings/src/main/res/values-cs/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Přepínejte, synchronizujte, upravujte a řešte problémy se zdroji IPTV.</string><string name="settings_title">Nastavení</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-da/strings.xml b/feature/settings/src/main/res/values-da/strings.xmlindex 1373db70..32b3dd5b 100644--- a/feature/settings/src/main/res/values-da/strings.xml+++ b/feature/settings/src/main/res/values-da/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Skift, synkroniser, rediger og fejlfind dine IPTV-kilder.</string><string name="settings_title">Indstillinger</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-de/strings.xml b/feature/settings/src/main/res/values-de/strings.xmlindex 5901b08d..068c27a7 100644--- a/feature/settings/src/main/res/values-de/strings.xml+++ b/feature/settings/src/main/res/values-de/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Wechseln, synchronisieren, bearbeiten und beheben Sie Ihre IPTV-Quellen.</string><string name="settings_title">Einstellungen</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-el/strings.xml b/feature/settings/src/main/res/values-el/strings.xmlindex 0d01e821..51fbf779 100644--- a/feature/settings/src/main/res/values-el/strings.xml+++ b/feature/settings/src/main/res/values-el/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Εναλλαγή, συγχρονισμός, επεξεργασία και αντιμετώπιση προβλημάτων των πηγών IPTV σας.</string><string name="settings_title">Ρυθμίσεις</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-es/strings.xml b/feature/settings/src/main/res/values-es/strings.xmlindex 8f4f96d4..08070e06 100644--- a/feature/settings/src/main/res/values-es/strings.xml+++ b/feature/settings/src/main/res/values-es/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Cambie, sincronice, edite y solucione problemas de sus fuentes de IPTV.</string><string name="settings_title">Ajustes</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-fi/strings.xml b/feature/settings/src/main/res/values-fi/strings.xmlindex 366a9201..2ddd20db 100644--- a/feature/settings/src/main/res/values-fi/strings.xml+++ b/feature/settings/src/main/res/values-fi/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Vaihda, synkronoi, muokkaa IPTV-lähteitäsi ja tee vianetsintää.</string><string name="settings_title">Asetukset</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-fr/strings.xml b/feature/settings/src/main/res/values-fr/strings.xmlindex b76a867e..6d18e7a7 100644--- a/feature/settings/src/main/res/values-fr/strings.xml+++ b/feature/settings/src/main/res/values-fr/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Changez, synchronisez, modifiez et dépannez vos sources IPTV.</string><string name="settings_title">Paramètres</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-hu/strings.xml b/feature/settings/src/main/res/values-hu/strings.xmlindex d95346ff..4934ac68 100644--- a/feature/settings/src/main/res/values-hu/strings.xml+++ b/feature/settings/src/main/res/values-hu/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Váltsa, szinkronizálja, szerkessze és hárítsa el az IPTV-forrásokat.</string><string name="settings_title">Beállítások elemre</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-in/strings.xml b/feature/settings/src/main/res/values-in/strings.xmlindex 112511d8..1bd342e0 100644--- a/feature/settings/src/main/res/values-in/strings.xml+++ b/feature/settings/src/main/res/values-in/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Beralih, sinkronkan, edit, dan pecahkan masalah sumber IPTV Anda.</string><string name="settings_title">Pengaturan</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-it/strings.xml b/feature/settings/src/main/res/values-it/strings.xmlindex 147fc2d0..ca27357e 100644--- a/feature/settings/src/main/res/values-it/strings.xml+++ b/feature/settings/src/main/res/values-it/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Cambia, sincronizza, modifica e risolvi i problemi delle tue sorgenti IPTV.</string><string name="settings_title">Impostazioni</string>+<string name="dashboard_trakt_watchlist_movies">Film nella watchlist Trakt</string>+<string name="dashboard_trakt_watchlist_series">Serie nella watchlist Trakt</string></resources>diff --git a/feature/settings/src/main/res/values-iw/strings.xml b/feature/settings/src/main/res/values-iw/strings.xmlindex 96c1e65b..3bcb21e8 100644--- a/feature/settings/src/main/res/values-iw/strings.xml+++ b/feature/settings/src/main/res/values-iw/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">החלף, סנכרן, ערוך ופתור בעיות במקורות ה-IPTV שלך.</string><string name="settings_title">הגדרות</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-ja/strings.xml b/feature/settings/src/main/res/values-ja/strings.xmlindex 4c9917ee..65fb8285 100644--- a/feature/settings/src/main/res/values-ja/strings.xml+++ b/feature/settings/src/main/res/values-ja/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">IPTVソースの切り替え、同期、編集、トラブルシュートを行います。</string><string name="settings_title">設定</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-ko/strings.xml b/feature/settings/src/main/res/values-ko/strings.xmlindex 8fe50912..a66209c5 100644--- a/feature/settings/src/main/res/values-ko/strings.xml+++ b/feature/settings/src/main/res/values-ko/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">IPTV 소스를 전환, 동기화, 편집, 문제 해결하세요.</string><string name="settings_title">설정</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-nb/strings.xml b/feature/settings/src/main/res/values-nb/strings.xmlindex 1825511f..9a84aaf0 100644--- a/feature/settings/src/main/res/values-nb/strings.xml+++ b/feature/settings/src/main/res/values-nb/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Bytt, synkroniser, rediger og feilsøk IPTV-kildene dine.</string><string name="settings_title">Innstillinger</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-nl/strings.xml b/feature/settings/src/main/res/values-nl/strings.xmlindex 1a968fb6..73b51e60 100644--- a/feature/settings/src/main/res/values-nl/strings.xml+++ b/feature/settings/src/main/res/values-nl/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Schakel, synchroniseer, bewerk en los problemen op met uw IPTV-bronnen.</string><string name="settings_title">Instellingen</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-pl/strings.xml b/feature/settings/src/main/res/values-pl/strings.xmlindex 4e27b8f1..fd282911 100644--- a/feature/settings/src/main/res/values-pl/strings.xml+++ b/feature/settings/src/main/res/values-pl/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Przełączaj, synchronizuj, edytuj i rozwiązuj problemy ze źródłami IPTV.</string><string name="settings_title">Ustawienia</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-pt/strings.xml b/feature/settings/src/main/res/values-pt/strings.xmlindex b7ad7232..1abf7c13 100644--- a/feature/settings/src/main/res/values-pt/strings.xml+++ b/feature/settings/src/main/res/values-pt/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Troque, sincronize, edite e solucione problemas de suas fontes de IPTV.</string><string name="settings_title">Configurações</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-ro/strings.xml b/feature/settings/src/main/res/values-ro/strings.xmlindex 292820c8..1a0899ce 100644--- a/feature/settings/src/main/res/values-ro/strings.xml+++ b/feature/settings/src/main/res/values-ro/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Comutați, sincronizați, editați și depanați-vă sursele IPTV.</string><string name="settings_title">Setări</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-ru/strings.xml b/feature/settings/src/main/res/values-ru/strings.xmlindex 4b99e425..e1c520c6 100644--- a/feature/settings/src/main/res/values-ru/strings.xml+++ b/feature/settings/src/main/res/values-ru/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Переключайте, синхронизируйте, редактируйте и устраняйте неполадки в источниках IPTV.</string><string name="settings_title">Настройки</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-sv/strings.xml b/feature/settings/src/main/res/values-sv/strings.xmlindex caf89335..3cc35067 100644--- a/feature/settings/src/main/res/values-sv/strings.xml+++ b/feature/settings/src/main/res/values-sv/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Växla, synka, redigera och felsök dina IPTV-källor.</string><string name="settings_title">Inställningar</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-tr/strings.xml b/feature/settings/src/main/res/values-tr/strings.xmlindex efd60030..41200e3b 100644--- a/feature/settings/src/main/res/values-tr/strings.xml+++ b/feature/settings/src/main/res/values-tr/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">IPTV kaynaklarınızı değiştirin, senkronize edin, düzenleyin ve sorun giderin.</string><string name="settings_title">Ayarlar</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-uk/strings.xml b/feature/settings/src/main/res/values-uk/strings.xmlindex a1b619ca..9898e3d7 100644--- a/feature/settings/src/main/res/values-uk/strings.xml+++ b/feature/settings/src/main/res/values-uk/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Перемикайте, синхронізуйте, редагуйте та усувайте проблеми з вашими IPTV-джерелами.</string><string name="settings_title">Налаштування</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-vi/strings.xml b/feature/settings/src/main/res/values-vi/strings.xmlindex c359ba12..c2b7fed0 100644--- a/feature/settings/src/main/res/values-vi/strings.xml+++ b/feature/settings/src/main/res/values-vi/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">Chuyển đổi, đồng bộ, chỉnh sửa và khắc phục nguồn IPTV của bạn.</string><string name="settings_title">Cài đặt</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values-zh/strings.xml b/feature/settings/src/main/res/values-zh/strings.xmlindex df183501..d7931030 100644--- a/feature/settings/src/main/res/values-zh/strings.xml+++ b/feature/settings/src/main/res/values-zh/strings.xml@@ -681,4 +681,6 @@<string name="settings_drive_manage_title">Saved Drive backups</string><string name="settings_providers_subtitle">切换、同步、编辑并排查您的 IPTV 来源。</string><string name="settings_title">设置</string>+<string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+<string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string></resources>diff --git a/feature/settings/src/main/res/values/strings.xml b/feature/settings/src/main/res/values/strings.xmlindex 868ee14a..7cbbf5e9 100644--- a/feature/settings/src/main/res/values/strings.xml+++ b/feature/settings/src/main/res/values/strings.xml@@ -9,6 +9,8 @@<string name="dashboard_pinned_categories">Pinned Categories</string><string name="dashboard_favorite_movies">Favorite Movies</string><string name="dashboard_favorite_series">Favorite Series</string>+ <string name="dashboard_trakt_watchlist_movies">Trakt Watchlist Movies</string>+ <string name="dashboard_trakt_watchlist_series">Trakt Watchlist Series</string><string name="dashboard_continue_watching_movies">Continue Watching Movies</string><string name="dashboard_continue_watching_series">Continue Watching Series</string><string name="dashboard_top_rated_movies">Top Rated Movies</string>@@ -226,6 +228,14 @@<string name="settings_vod_portal_search">Portal-backed VOD search</string><string name="settings_vod_portal_search_off">Use the locally indexed VOD catalog for search.</string><string name="settings_vod_portal_search_on">Ask Stalker portals to search VOD before the full catalog is indexed.</string>+ <string name="settings_trakt_discovery_title">Trakt discovery categories</string>+ <string name="settings_trakt_discovery_description">Choose which Trending and Popular categories appear in Movies and Series.</string>+ <string name="settings_trakt_discovery_trending_movies">Trending movies on Trakt</string>+ <string name="settings_trakt_discovery_popular_movies">Popular movies on Trakt</string>+ <string name="settings_trakt_discovery_trending_series">Trending series on Trakt</string>+ <string name="settings_trakt_discovery_popular_series">Popular series on Trakt</string>+ <string name="settings_trakt_discovery_visible">Visible</string>+ <string name="settings_trakt_discovery_hidden">Hidden</string><string name="settings_retry_epg">Retry EPG</string><string name="settings_retry_movies">Retry Movies</string><string name="settings_retry_series">Retry Series</string>diff --git a/feature/settings/src/main/res/values/trakt_strings.xml b/feature/settings/src/main/res/values/trakt_strings.xmlnew file mode 100644index 00000000..10d105ed--- /dev/null+++ b/feature/settings/src/main/res/values/trakt_strings.xml@@ -0,0 +1,69 @@+<resources>+ <string name="trakt_sync_now" translatable="false">Sync Now</string>+ <string name="trakt_sync_description" translatable="false">Sync watched movies and episodes with Trakt. Newer local progress and manual completion are preserved.</string>+ <string name="trakt_sync_complete" translatable="false">Imported %1$d · Uploaded %2$d · Unchanged %3$d · Unmatched %4$d · Skipped %5$d</string>+ <string name="trakt_sync_failed" translatable="false">Sync could not finish. Trakt history is checked before another upload.</string>+ <string name="trakt_sync_limit" translatable="false">Your history exceeds this sync’s limit. No items were imported.</string>+ <string name="trakt_sync_incognito" translatable="false">Turn off Incognito mode to sync watch history.</string>+ <string name="trakt_sync_more_uploads" translatable="false">There may be more local history to upload. Select Sync Now again to continue.</string>+ <string name="settings_trakt" translatable="false">Trakt</string>+ <string name="settings_trakt_description" translatable="false">Connect your Trakt account and sync watched history.</string>+ <string name="trakt_connect" translatable="false">Connect Trakt</string>+ <string name="trakt_disconnect" translatable="false">Disconnect</string>+ <string name="trakt_connected" translatable="false">Connected</string>+ <string name="trakt_disconnected" translatable="false">Disconnected</string>+ <string name="trakt_refresh_profile" translatable="false">Refresh profile</string>+ <string name="trakt_profile_name" translatable="false">Name: %1$s</string>+ <string name="trakt_profile_location" translatable="false">Location: %1$s</string>+ <string name="trakt_profile_joined" translatable="false">Joined Trakt: %1$s</string>+ <string name="trakt_profile_gender" translatable="false">Gender: %1$s</string>+ <string name="trakt_profile_age" translatable="false">Age: %1$d</string>+ <string name="trakt_profile_vip" translatable="false">Trakt VIP</string>+ <string name="trakt_profile_about" translatable="false">About: %1$s</string>+ <string name="trakt_scrobbling_setting" translatable="false">Playback scrobbling</string>+ <string name="trakt_history_sync_setting" translatable="false">History import and upload</string>+ <string name="trakt_setting_enabled" translatable="false">On</string>+ <string name="trakt_setting_disabled" translatable="false">Off</string>+ <string name="trakt_import_favorites" translatable="false">Import Trakt favorites to this provider</string>+ <string name="trakt_import_favorites_result" translatable="false">Added %1$d · Already favorited %2$d · Not in provider %3$d · Skipped %4$d</string>+ <string name="trakt_favorites_import_failed" translatable="false">Could not finish importing Trakt favorites. Added so far: %1$d.</string>+ <string name="trakt_favorites_connect_first" translatable="false">Connect Trakt before importing favorites.</string>+ <string name="trakt_favorites_incognito" translatable="false">Turn off Incognito mode to import Trakt favorites.</string>+ <string name="trakt_favorites_provider_required" translatable="false">Select an active provider before importing favorites.</string>+ <string name="trakt_favorites_too_large" translatable="false">This Trakt favorites list exceeds the import limit. Nothing was imported.</string>+ <string name="trakt_cancel" translatable="false">Cancel sign-in</string>+ <string name="trakt_complete_browser" translatable="false">Complete sign-in in your browser.</string>+ <string name="trakt_configuration_required" translatable="false">Trakt sign-in is not configured for this build.</string>+ <string name="trakt_sign_in_failed" translatable="false">Could not connect to Trakt. Please try again.</string>+ <string name="trakt_browser_required" translatable="false">Install a browser on this device, then try connecting to Trakt again.</string>+ <string name="trakt_network_error" translatable="false">Could not reach Trakt. Try again when connected.</string>+ <string name="trakt_reconnect_required" translatable="false">Your Trakt session has expired. Please reconnect.</string>+ <string name="trakt_rate_limited" translatable="false">Trakt is busy. Please try again later.</string>+ <string name="trakt_custom_lists_title" translatable="false">Custom Trakt lists</string>+ <string name="trakt_custom_lists_description" translatable="false">Manage your lists, change their order, and remove items. Movie and show details can add movies, shows, seasons, or episodes.</string>+ <string name="trakt_custom_lists_refresh" translatable="false">Refresh lists</string>+ <string name="trakt_custom_lists_create" translatable="false">Create private list</string>+ <string name="trakt_custom_lists_name" translatable="false">List name</string>+ <string name="trakt_custom_lists_optional_description" translatable="false">Description (optional)</string>+ <string name="trakt_custom_lists_private_note" translatable="false">New lists are private on Trakt.</string>+ <string name="trakt_custom_lists_not_loaded" translatable="false">Refresh to load your lists.</string>+ <string name="trakt_custom_lists_no_items" translatable="false">This list has no supported movie, show, season, or episode items.</string>+ <string name="trakt_custom_list_open_with_privacy" translatable="false">%1$s · %2$d items · %3$s</string>+ <string name="trakt_custom_lists_loading" translatable="false">Loading list information…</string>+ <string name="trakt_custom_lists_empty" translatable="false">You have no custom lists yet. Create one above.</string>+ <string name="trakt_custom_lists_connect_first" translatable="false">Connect Trakt in Settings to use your lists.</string>+ <string name="trakt_custom_lists_failed" translatable="false">Could not load or update this Trakt list. Try again.</string>+ <string name="trakt_custom_lists_incognito" translatable="false">Trakt lists are unavailable while Incognito mode is on.</string>+ <string name="trakt_custom_lists_too_large" translatable="false">This list is too large to load completely in StreamVault.</string>+ <string name="trakt_custom_list_remove_item" translatable="false">Remove</string>+ <string name="trakt_custom_lists_delete" translatable="false">Delete</string>+ <string name="trakt_custom_lists_delete_title" translatable="false">Delete this Trakt list?</string>+ <string name="trakt_custom_lists_delete_message" translatable="false">“%1$s” and all of its items will be deleted from your Trakt account.</string>+ <string name="trakt_custom_lists_move_up" translatable="false">Move up</string>+ <string name="trakt_custom_lists_move_down" translatable="false">Move down</string>+ <string name="trakt_custom_list_items_truncated" translatable="false">Showing the first 200 items.</string>+ <plurals name="trakt_sync_imported_count" translatable="false">+ <item quantity="one">%1$d local item imported.</item>+ <item quantity="other">%1$d local items imported.</item>+ </plurals>+</resources>diff --git a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/TraktSettingsViewModelTest.kt b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/TraktSettingsViewModelTest.ktnew file mode 100644index 00000000..80c2b128--- /dev/null+++ b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/TraktSettingsViewModelTest.kt@@ -0,0 +1,127 @@+package com.streamvault.feature.settings.presentation++import android.content.ActivityNotFoundException+import com.streamvault.domain.trakt.TraktAccount+import com.streamvault.domain.trakt.TraktAccountState+import com.streamvault.domain.trakt.TraktFeaturePreferences+import com.streamvault.domain.trakt.TraktFavoriteImporter+import com.streamvault.domain.trakt.TraktFavoriteImportResult+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.ExperimentalCoroutinesApi+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.Flow+import kotlinx.coroutines.test.StandardTestDispatcher+import kotlinx.coroutines.test.advanceUntilIdle+import kotlinx.coroutines.test.resetMain+import kotlinx.coroutines.test.runTest+import kotlinx.coroutines.test.setMain+import org.junit.Assert.*+import org.junit.Test+import org.junit.runner.RunWith+import org.robolectric.RobolectricTestRunner++@OptIn(ExperimentalCoroutinesApi::class)+@RunWith(RobolectricTestRunner::class)+class TraktSettingsViewModelTest {+ private val historySync = object : com.streamvault.domain.trakt.TraktHistorySync {+ override suspend fun sync() = com.streamvault.domain.trakt.TraktHistorySyncResult.Success(0, 0, 0, 0)+ }+ private val favoriteImporter = object : TraktFavoriteImporter {+ override suspend fun importToLocal() = TraktFavoriteImportResult.Success(0, 0, 0, 0)+ }++ @Test fun `manual history sync is single flight and reports counts`() = runTest {+ Dispatchers.setMain(StandardTestDispatcher(testScheduler))+ try {+ var calls = 0+ val sync = object : com.streamvault.domain.trakt.TraktHistorySync {+ override suspend fun sync(): com.streamvault.domain.trakt.TraktHistorySyncResult {+ calls+++ return com.streamvault.domain.trakt.TraktHistorySyncResult.Success(2, 3, 4, 5)+ }+ }+ val viewModel = TraktSettingsViewModel(Account(), sync, FeaturePreferences(), favoriteImporter)+ advanceUntilIdle()+ viewModel.syncHistory()+ viewModel.syncHistory()+ advanceUntilIdle()+ assertEquals(1, calls)+ assertEquals(com.streamvault.domain.trakt.TraktHistorySyncResult.Success(2, 3, 4, 5), viewModel.syncResult.value)+ assertFalse(viewModel.busy.value)+ viewModel.disconnect()+ advanceUntilIdle()+ assertNull(viewModel.syncResult.value)+ } finally { Dispatchers.resetMain() }+ }++ @Test fun `disabled history sync prevents manual sync and preference toggles persist`() = runTest {+ Dispatchers.setMain(StandardTestDispatcher(testScheduler))+ try {+ var calls = 0+ val sync = object : com.streamvault.domain.trakt.TraktHistorySync {+ override suspend fun sync(): com.streamvault.domain.trakt.TraktHistorySyncResult {+ calls+++ return com.streamvault.domain.trakt.TraktHistorySyncResult.Success(0, 0, 0, 0)+ }+ }+ val preferences = FeaturePreferences()+ val viewModel = TraktSettingsViewModel(Account(), sync, preferences, favoriteImporter)+ advanceUntilIdle()+ viewModel.setHistorySyncEnabled(false)+ viewModel.setScrobblingEnabled(false)+ advanceUntilIdle()+ viewModel.syncHistory()+ advanceUntilIdle()+ assertFalse(viewModel.historySyncEnabled.value)+ assertFalse(viewModel.scrobblingEnabled.value)+ assertEquals(0, calls)+ } finally { Dispatchers.resetMain() }+ }+ private class Account : TraktAccount {+ override val state = MutableStateFlow(TraktAccountState(configured = true))+ var cancellations = 0+ override suspend fun load() = Unit+ override suspend fun beginSignIn(): String {+ state.value = state.value.copy(connecting = true)+ return "https://auth.trakt.tv/oauth/authorize"+ }+ override suspend fun cancelSignIn() {+ cancellations+++ state.value = state.value.copy(connecting = false)+ }+ override suspend fun completeSignIn(callback: String) = Unit+ override suspend fun disconnect() = Unit+ override suspend fun refreshProfile() = Unit+ }++ private class FeaturePreferences : TraktFeaturePreferences {+ private val scrobbling = MutableStateFlow(true)+ private val history = MutableStateFlow(true)+ override val scrobblingEnabled: Flow<Boolean> = scrobbling+ override val historySyncEnabled: Flow<Boolean> = history+ override suspend fun setScrobblingEnabled(enabled: Boolean) { scrobbling.value = enabled }+ override suspend fun setHistorySyncEnabled(enabled: Boolean) { history.value = enabled }+ }++ @Test fun `missing browser cancels pending login and allows retry after browser is installed`() = runTest {+ Dispatchers.setMain(StandardTestDispatcher(testScheduler))+ try {+ val account = Account()+ val viewModel = TraktSettingsViewModel(account, historySync, FeaturePreferences(), favoriteImporter)+ advanceUntilIdle()+ viewModel.connect { throw ActivityNotFoundException() }+ advanceUntilIdle()+ assertEquals(1, account.cancellations)+ assertFalse(account.state.value.connecting)+ assertTrue(viewModel.browserUnavailable.value)+ assertFalse(viewModel.failed.value)+ assertFalse(viewModel.busy.value)+ var browserOpened = false+ viewModel.connect { browserOpened = true }+ advanceUntilIdle()+ assertTrue(browserOpened)+ assertTrue(account.state.value.connecting)+ assertFalse(viewModel.browserUnavailable.value)+ } finally { Dispatchers.resetMain() }+ }+}diff --git a/local.properties.example b/local.properties.exampleindex 58027119..b04ec668 100644--- a/local.properties.example+++ b/local.properties.example@@ -16,6 +16,12 @@# See `docs/DEV_SEEDING.md` for the full opt-in onboarding flow.# -----------------------------------------------------------------------------+# === Trakt app configuration (all build types; public, not user credentials) ===+# Environment TRAKT_CLIENT_ID / TRAKT_REDIRECT_URI take precedence.+# Register this exact HTTPS URI with Trakt and publish assetlinks.json on its domain.+# trakt.client.id=your-public-streamvault-client-id+# trakt.redirect.uri=https://your-domain.example/oauth/trakt/callback+# === Dev onboarding seeding (optional) ========================================#