StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
feat: implement database startup coordination and migration handling
David Nashashc4f112cf349f
diff --git a/app/build.gradle.kts b/app/build.gradle.ktsindex bb027d16..8b9ddf59 100644--- a/app/build.gradle.kts+++ b/app/build.gradle.kts@@ -57,8 +57,8 @@ android {applicationId = "com.streamvault.app"minSdk = 25targetSdk = 36- versionCode = 18- versionName = "1.0.17"+ versionCode = 19+ versionName = "1.0.17.1"testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"providers.gradleProperty("compatApi").orNull?.let { expectedApi ->testInstrumentationRunnerArguments["expected_api"] = expectedApidiff --git a/app/src/main/java/com/streamvault/app/DatabaseStartupGate.kt b/app/src/main/java/com/streamvault/app/DatabaseStartupGate.ktnew file mode 100644index 00000000..a624c38f--- /dev/null+++ b/app/src/main/java/com/streamvault/app/DatabaseStartupGate.kt@@ -0,0 +1,98 @@+package com.streamvault.app++import android.content.Context+import com.streamvault.app.diagnostics.CrashReportStore+import com.streamvault.data.local.StreamVaultDatabase+import dagger.Lazy+import dagger.hilt.android.qualifiers.ApplicationContext+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.StateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.launch+import kotlinx.coroutines.supervisorScope+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import javax.inject.Inject+import javax.inject.Singleton++sealed interface DatabaseStartupState {+ data object Opening : DatabaseStartupState+ data object Ready : DatabaseStartupState+ data class Failed(+ val errorType: String,+ val userMessage: String = "The local database could not be upgraded. Your data was not deleted."+ ) : DatabaseStartupState+}++internal class DatabaseStartupGate(+ private val onFailure: (Throwable) -> Unit = {},+ private val openDatabase: suspend () -> Unit+) {+ private val mutex = Mutex()+ private val mutableState = MutableStateFlow<DatabaseStartupState>(DatabaseStartupState.Opening)+ val state: StateFlow<DatabaseStartupState> = mutableState.asStateFlow()++ suspend fun open() {+ mutex.withLock {+ if (mutableState.value == DatabaseStartupState.Ready) return+ mutableState.value = DatabaseStartupState.Opening+ try {+ openDatabase()+ mutableState.value = DatabaseStartupState.Ready+ } catch (error: CancellationException) {+ throw error+ } catch (error: Throwable) {+ runCatching { onFailure(error) }+ mutableState.value = DatabaseStartupState.Failed(+ errorType = error.javaClass.simpleName.ifBlank { "DatabaseOpenError" }+ )+ }+ }+ }+}++@Singleton+class DatabaseStartupCoordinator @Inject constructor(+ database: Lazy<StreamVaultDatabase>,+ @ApplicationContext context: Context+) {+ private val gate = DatabaseStartupGate(+ openDatabase = {+ withContext(Dispatchers.IO) {+ database.get().openHelper.writableDatabase+ }+ },+ onFailure = { error ->+ CrashReportStore.recordHandledFailure(context, "database-startup", error)+ }+ )++ val state: StateFlow<DatabaseStartupState> = gate.state++ suspend fun open() = gate.open()+}++internal data class StartupTask(+ val name: String,+ val action: suspend () -> Unit+)++internal suspend fun runContainedStartupTasks(+ tasks: List<StartupTask>,+ onFailure: (String, Throwable) -> Unit+) = supervisorScope {+ tasks.forEach { task ->+ launch {+ try {+ task.action()+ } catch (error: CancellationException) {+ throw error+ } catch (error: Throwable) {+ onFailure(task.name, error)+ }+ }+ }+}diff --git a/app/src/main/java/com/streamvault/app/MainActivity.kt b/app/src/main/java/com/streamvault/app/MainActivity.ktindex 85465d9e..a7c7c5e9 100644--- a/app/src/main/java/com/streamvault/app/MainActivity.kt+++ b/app/src/main/java/com/streamvault/app/MainActivity.kt@@ -36,6 +36,22 @@ import com.streamvault.data.preferences.PreferencesRepositoryimport androidx.compose.runtime.collectAsStateimport androidx.compose.runtime.getValueimport androidx.compose.runtime.remember+import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.Composable+import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.fillMaxSize+import androidx.compose.foundation.layout.padding+import androidx.compose.material3.CircularProgressIndicator+import androidx.compose.material3.MaterialTheme+import androidx.compose.material3.Surface+import androidx.compose.material3.Text+import androidx.tv.material3.Button+import androidx.compose.ui.Alignment+import androidx.compose.ui.Modifier+import androidx.compose.ui.text.style.TextAlign+import androidx.compose.ui.unit.dpimport androidx.compose.ui.platform.LocalContextimport androidx.compose.ui.platform.LocalLayoutDirectionimport androidx.compose.runtime.CompositionLocalProvider@@ -57,6 +73,7 @@ import kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.flow.StateFlowimport kotlinx.coroutines.flow.asStateFlowimport kotlinx.coroutines.launch+import com.streamvault.app.diagnostics.CrashReportStore@AndroidEntryPointclass MainActivity : ComponentActivity() {@@ -105,6 +122,9 @@ class MainActivity : ComponentActivity() {@Injectlateinit var castManager: CastManager+ @Inject+ lateinit var databaseStartupCoordinator: DatabaseStartupCoordinator+private val _pictureInPictureModeFlow = MutableStateFlow(false)val pictureInPictureModeFlow: StateFlow<Boolean> = _pictureInPictureModeFlow.asStateFlow()@@ -131,16 +151,10 @@ class MainActivity : ComponentActivity() {applyImmersiveSystemUi()_pictureInPictureModeFlow.value = isInPictureInPictureModehandleExternalIntent(intent)- if (isTelevisionDevice()) {- lifecycleScope.launch {- watchNextManager.refreshWatchNext()- launcherRecommendationsManager.refreshRecommendations()- tvInputChannelSyncManager.refreshTvInputCatalog()- }- }setContent {val appLanguage by preferencesRepository.appLanguage.collectAsState(initial = "system")val appTimeFormat by preferencesRepository.appTimeFormat.collectAsState(initial = com.streamvault.domain.model.AppTimeFormat.SYSTEM)+ val databaseStartupState by databaseStartupCoordinator.state.collectAsState()val currentContext = LocalContext.currentval configuration = remember(appLanguage) {@@ -183,7 +197,26 @@ class MainActivity : ComponentActivity() {LocalAppTimeFormat provides appTimeFormat) {StreamVaultTheme {- AppNavigation(mainActivity = this@MainActivity)+ when (val state = databaseStartupState) {+ DatabaseStartupState.Opening -> DatabaseStartupScreen(state = state)+ is DatabaseStartupState.Failed -> DatabaseStartupScreen(+ state = state,+ onRetry = {+ lifecycleScope.launch { databaseStartupCoordinator.open() }+ },+ onShareReport = ::shareLatestFailureReport+ )+ DatabaseStartupState.Ready -> {+ LaunchedEffect(Unit) {+ if (isTelevisionDevice()) {+ watchNextManager.refreshWatchNext()+ launcherRecommendationsManager.refreshRecommendations()+ tvInputChannelSyncManager.refreshTvInputCatalog()+ }+ }+ AppNavigation(mainActivity = this@MainActivity)+ }+ }}}}@@ -346,6 +379,15 @@ class MainActivity : ComponentActivity() {_externalNavigationRequestFlow.value = request}+ private fun shareLatestFailureReport() {+ val file = CrashReportStore.latestReportFile(this)+ if (!file.isFile || file.length() <= 0L) return+ runCatching {+ val uri = CrashReportStore.providerUriForFile(this, file)+ startActivity(CrashReportStore.buildShareIntent(uri))+ }+ }+private fun Intent.toExternalNavigationRequest(): ExternalNavigationRequest? {readPlayerRequestExtra()?.let { return ExternalNavigationRequest.Player(it) }readExternalDestinationExtra()?.let { return ExternalNavigationRequest.Destination(it) }@@ -451,3 +493,49 @@ class MainActivity : ComponentActivity() {}}}++@Composable+private fun DatabaseStartupScreen(+ state: DatabaseStartupState,+ onRetry: () -> Unit = {},+ onShareReport: () -> Unit = {}+) {+ Surface(modifier = Modifier.fillMaxSize()) {+ Column(+ modifier = Modifier.fillMaxSize().padding(48.dp),+ verticalArrangement = Arrangement.Center,+ horizontalAlignment = Alignment.CenterHorizontally+ ) {+ when (state) {+ DatabaseStartupState.Opening -> {+ CircularProgressIndicator()+ Text(+ text = "Preparing your library…",+ modifier = Modifier.padding(top = 24.dp),+ style = MaterialTheme.typography.titleLarge+ )+ }+ is DatabaseStartupState.Failed -> {+ Text(+ text = "StreamVault couldn't open your library",+ style = MaterialTheme.typography.headlineSmall,+ textAlign = TextAlign.Center+ )+ Text(+ text = "${state.userMessage}\nError: ${state.errorType}",+ modifier = Modifier.padding(top = 16.dp),+ textAlign = TextAlign.Center+ )+ Row(+ modifier = Modifier.padding(top = 28.dp),+ horizontalArrangement = Arrangement.spacedBy(16.dp)+ ) {+ Button(onClick = onRetry) { Text("Retry") }+ Button(onClick = onShareReport) { Text("Share report") }+ }+ }+ DatabaseStartupState.Ready -> Unit+ }+ }+ }+}diff --git a/app/src/main/java/com/streamvault/app/StreamVaultApp.kt b/app/src/main/java/com/streamvault/app/StreamVaultApp.ktindex 7bd2ec30..9c4127cf 100644--- a/app/src/main/java/com/streamvault/app/StreamVaultApp.kt+++ b/app/src/main/java/com/streamvault/app/StreamVaultApp.kt@@ -1,6 +1,7 @@package com.streamvault.appimport android.app.Application+import android.util.Logimport coil3.ImageLoaderimport coil3.PlatformContextimport coil3.SingletonImageLoader@@ -20,6 +21,8 @@ import kotlinx.coroutines.CoroutineScopeimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.SupervisorJobimport kotlinx.coroutines.launch+import kotlinx.coroutines.flow.filterIsInstance+import kotlinx.coroutines.flow.firstimport okio.Path.Companion.toOkioPathimport androidx.work.Constraints@@ -65,6 +68,9 @@ class StreamVaultApp : Application(), SingletonImageLoader.Factory {@Injectlateinit var pendingBackupRestoreCoordinator: PendingBackupRestoreCoordinator+ @Inject+ lateinit var databaseStartupCoordinator: DatabaseStartupCoordinator+private val imageOkHttpClient: OkHttpClient by lazy {okHttpClient.newBuilder().addInterceptor(jellyfinImageAuthInterceptor)@@ -76,27 +82,46 @@ class StreamVaultApp : Application(), SingletonImageLoader.Factory {CrashReportStore.install(this)runtimeDiagnosticsManager.start()applicationScope.launch {- // Clean up any timeshift temp directories left behind by crashes, OOM kills, or- // force-stops from the previous run. activeSessionDir = null means wipe everything.- TimeshiftDiskManager(applicationContext).cleanupStaleDirectories(activeSessionDir = null)- }- applicationScope.launch {- downloadManager.recoverInterruptedDownloads()+ databaseStartupCoordinator.state+ .filterIsInstance<DatabaseStartupState.Ready>()+ .first()+ runDatabaseReadyStartupTasks()}applicationScope.launch {- streamVaultPluginManager.reconcilePluginProviders()+ databaseStartupCoordinator.open()}- applicationScope.launch {- programReminderManager.restoreScheduledReminders()- }- applicationScope.launch {- providerSyncLifecycle.reconcileStalkerIndexWorkAtStartup()- }- applicationScope.launch {- pendingBackupRestoreCoordinator.applyAllAvailable()- }-- startupWorkRegistry.register()+ }++ private suspend fun runDatabaseReadyStartupTasks() {+ runContainedStartupTasks(+ tasks = listOf(+ StartupTask("timeshift-cleanup") {+ TimeshiftDiskManager(applicationContext)+ .cleanupStaleDirectories(activeSessionDir = null)+ },+ StartupTask("download-recovery") {+ downloadManager.recoverInterruptedDownloads()+ },+ StartupTask("plugin-reconcile") {+ streamVaultPluginManager.reconcilePluginProviders()+ },+ StartupTask("reminder-restore") {+ programReminderManager.restoreScheduledReminders()+ },+ StartupTask("stalker-work-reconcile") {+ providerSyncLifecycle.reconcileStalkerIndexWorkAtStartup()+ },+ StartupTask("pending-backup-restore") {+ pendingBackupRestoreCoordinator.applyAllAvailable()+ },+ StartupTask("work-registration") {+ startupWorkRegistry.register()+ }+ ),+ onFailure = { name, error ->+ Log.e("StreamVaultStartup", "Startup task failed: $name", error)+ }+ )}override fun onTerminate() {diff --git a/app/src/main/java/com/streamvault/app/diagnostics/CrashReportStore.kt b/app/src/main/java/com/streamvault/app/diagnostics/CrashReportStore.ktindex 06003d2d..8199da71 100644--- a/app/src/main/java/com/streamvault/app/diagnostics/CrashReportStore.kt+++ b/app/src/main/java/com/streamvault/app/diagnostics/CrashReportStore.kt@@ -78,6 +78,17 @@ object CrashReportStore {fun deleteLatestReport(context: Context): Boolean =latestReportFile(context).delete()+ fun recordHandledFailure(context: Context, operation: String, throwable: Throwable) {+ runCatching {+ latestReportFile(context).writeText(+ buildReport(context, Thread.currentThread(), throwable)+ .replaceFirst("StreamVault Crash Report", "StreamVault Failure Report")+ .plus("\nOperation: ${sanitize(operation)}\n"),+ Charsets.UTF_8+ )+ }+ }+fun providerUriForFile(context: Context, file: File): Uri =FileProvider.getUriForFile(context, "${BuildConfig.APPLICATION_ID}.fileprovider", file)diff --git a/app/src/test/java/com/streamvault/app/DatabaseStartupGateTest.kt b/app/src/test/java/com/streamvault/app/DatabaseStartupGateTest.ktnew file mode 100644index 00000000..44823827--- /dev/null+++ b/app/src/test/java/com/streamvault/app/DatabaseStartupGateTest.kt@@ -0,0 +1,63 @@+package com.streamvault.app++import com.google.common.truth.Truth.assertThat+import kotlinx.coroutines.async+import kotlinx.coroutines.test.runTest+import org.junit.Test++class DatabaseStartupGateTest {+ @Test+ fun `successful open transitions to ready`() = runTest {+ val gate = DatabaseStartupGate { }++ gate.open()++ assertThat(gate.state.value).isEqualTo(DatabaseStartupState.Ready)+ }++ @Test+ fun `failed open is contained and retry can recover`() = runTest {+ var attempts = 0+ val gate = DatabaseStartupGate {+ attempts+++ if (attempts == 1) error("jdbc:sqlite://secret-user:secret-password@host/database")+ }++ gate.open()+ val failure = gate.state.value as DatabaseStartupState.Failed+ assertThat(failure.errorType).isEqualTo("IllegalStateException")+ assertThat(failure.userMessage).doesNotContain("secret")++ gate.open()+ assertThat(gate.state.value).isEqualTo(DatabaseStartupState.Ready)+ assertThat(attempts).isEqualTo(2)+ }++ @Test+ fun `concurrent calls perform one database open`() = runTest {+ var attempts = 0+ val gate = DatabaseStartupGate { attempts++ }++ val calls = List(10) { async { gate.open() } }+ calls.forEach { it.await() }++ assertThat(attempts).isEqualTo(1)+ }++ @Test+ fun `one startup task failure does not cancel sibling tasks`() = runTest {+ val completed = mutableListOf<String>()+ val failures = mutableListOf<String>()++ runContainedStartupTasks(+ tasks = listOf(+ StartupTask("broken") { error("boom") },+ StartupTask("healthy") { completed += "healthy" }+ ),+ onFailure = { name, _ -> failures += name }+ )++ assertThat(completed).containsExactly("healthy")+ assertThat(failures).containsExactly("broken")+ }+}diff --git a/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.kt b/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.ktindex e818fbf4..ddcaba54 100644--- a/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.kt+++ b/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.kt@@ -1731,6 +1731,60 @@ class StreamVaultDatabaseMigrationTest {migrated.close()}+ @Test+ fun migrate72To73_preservesProvidersWhoseNormalizedIdentitiesCollide() {+ val name = "streamvault-72-73-normalized-duplicates"+ migrationTestHelper.createDatabase(name, 72).apply {+ insertProvider72(1, "Original", "XTREAM_CODES")+ insertProvider72(2, "Equivalent legacy URL", "XTREAM_CODES")+ execSQL("UPDATE providers SET server_url='https://host/',username='alice' WHERE id=1")+ execSQL("UPDATE providers SET server_url='https://host:443',username='alice' WHERE id=2")+ close()+ }++ val migrated = migrationTestHelper.runMigrationsAndValidate(+ name,+ 73,+ true,+ StreamVaultDatabase.MIGRATION_72_73+ )++ assertEquals(2, countRows(migrated, "SELECT COUNT(*) FROM providers"))+ assertEquals(2, countRows(migrated, "SELECT COUNT(*) FROM provider_configs"))+ assertEquals(2, countRows(migrated, "SELECT COUNT(DISTINCT identity_key) FROM provider_configs"))+ assertEquals(2, countRows(migrated, "SELECT COUNT(*) FROM provider_configs WHERE length(identity_key)=64"))+ migrated.close()+ }++ @Test+ fun migrate72To73_canonicalizesAliasesAndUnknownLegacyTypes() {+ val name = "streamvault-72-73-provider-aliases"+ migrationTestHelper.createDatabase(name, 72).apply {+ insertProvider72(1, "Xtream alias", "XTREAM_CODES_API")+ insertProvider72(2, "Stalker alias", "STB")+ insertProvider72(3, "Playlist alias", "PLAYLIST")+ insertProvider72(4, "Unknown playlist", "vendor_specific_playlist")+ execSQL("UPDATE providers SET server_url='https://x.test',username='alice' WHERE id=1")+ execSQL("UPDATE providers SET server_url='https://s.test',stalker_mac_address='00:11:22:33:44:55' WHERE id=2")+ execSQL("UPDATE providers SET m3u_url='https://m.test/one.m3u' WHERE id=3")+ execSQL("UPDATE providers SET m3u_url='https://m.test/two.m3u' WHERE id=4")+ close()+ }++ val migrated = migrationTestHelper.runMigrationsAndValidate(+ name,+ 73,+ true,+ StreamVaultDatabase.MIGRATION_72_73+ )++ assertEquals(1, countRows(migrated, "SELECT COUNT(*) FROM providers WHERE id=1 AND type='XTREAM_CODES'"))+ assertEquals(1, countRows(migrated, "SELECT COUNT(*) FROM providers WHERE id=2 AND type='STALKER_PORTAL'"))+ assertEquals(2, countRows(migrated, "SELECT COUNT(*) FROM providers WHERE id IN (3,4) AND type='M3U'"))+ assertEquals(4, countRows(migrated, "SELECT COUNT(*) FROM provider_configs"))+ migrated.close()+ }+@Testfun migrate72To74_rebuildsStableProvidersWithoutCatalogOrForeignKeyLoss() {val name = "streamvault-72-74-stable-provider-identity"diff --git a/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV49To75.kt b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV49To75.ktindex 4ad01f1b..a43f8937 100644--- a/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV49To75.kt+++ b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV49To75.kt@@ -6,7 +6,6 @@ import androidx.room.migration.Migrationimport androidx.sqlite.db.SupportSQLiteDatabaseimport org.json.JSONObjectimport java.net.URI-import java.security.MessageDigest/** Provider runtime, workflow, backup, plugin ownership, and typed-configuration migrations (v49 through v75). Executable bodies live here, outside the Room schema declaration. */internal object FeatureMigrationsV49To75 {@@ -115,6 +114,19 @@ internal object FeatureMigrationsV49To75 {}private fun backfillTypedProviderSnapshots(database: SupportSQLiteDatabase) {+ val canonicalTypes = mutableListOf<Pair<Long, String>>()+ database.query("SELECT id, type FROM providers ORDER BY id").use { cursor ->+ while (cursor.moveToNext()) {+ canonicalTypes += cursor.getLong(0) to canonicalLegacyProviderType(cursor.getString(1))+ }+ }+ canonicalTypes.forEach { (providerId, type) ->+ database.execSQL(+ "UPDATE providers SET type=? WHERE id=?",+ arrayOf<Any?>(type, providerId)+ )+ }+database.query("SELECT * FROM providers ORDER BY id").use { cursor ->fun text(name: String): String = cursor.getString(cursor.getColumnIndexOrThrow(name)) ?: ""fun long(name: String): Long = cursor.getLong(cursor.getColumnIndexOrThrow(name))@@ -185,7 +197,7 @@ internal object FeatureMigrationsV49To75 {.put("username", text("username")).put("credential", text("password")).put("schemaVersion", 1)- else -> throw IllegalStateException("Unknown provider type during migration: $type")+ else -> error("Provider type was not canonicalized: $type")}val identity = when (type) {"XTREAM_CODES", "JELLYFIN" -> listOf(type, migrationNormalizeOrigin(text("server_url")), text("username").trim())@@ -198,10 +210,19 @@ internal object FeatureMigrationsV49To75 {text("username").trim())else -> error("unreachable")- }.joinToString("\u0000")- val identityKey = MessageDigest.getInstance("SHA-256")- .digest(identity.toByteArray(Charsets.UTF_8))- .joinToString("") { "%02x".format(it) }+ }+ val canonicalIdentityKey = migrationIdentityKey(identity)+ val identityOwner = database.query(+ "SELECT provider_id FROM provider_configs WHERE identity_key=? LIMIT 1",+ arrayOf(canonicalIdentityKey)+ ).use { ownerCursor ->+ if (ownerCursor.moveToFirst()) ownerCursor.getLong(0) else null+ }+ val identityKey = if (identityOwner == null || identityOwner == providerId) {+ canonicalIdentityKey+ } else {+ disambiguatedMigrationIdentityKey(canonicalIdentityKey, providerId)+ }val updatedAt = long("last_synced_at").takeIf { it > 0L } ?: long("created_at")database.execSQL(@@ -1092,7 +1113,10 @@ internal object FeatureMigrationsV49To75 {database.execSQL("CREATE INDEX IF NOT EXISTS index_providers_type ON providers(type)")database.execSQL("CREATE INDEX IF NOT EXISTS index_providers_is_active ON providers(is_active)")restoreProviderDependentTables(database, providerDependents)- validateAllForeignKeys(database)+ validateForeignKeys(+ database,+ *providerDependents.map { it.table }.toTypedArray()+ )}}@@ -1275,20 +1299,6 @@ internal object FeatureMigrationsV49To75 {private fun quoteSqlIdentifier(value: String): String ="\"${value.replace("\"", "\"\"")}\""- private fun validateAllForeignKeys(database: SupportSQLiteDatabase) {- database.query("PRAGMA foreign_key_check").use { cursor ->- if (cursor.moveToFirst()) {-- val table = if (!cursor.isNull(0)) cursor.getString(0) else "<unknown>"- val rowId = if (!cursor.isNull(1)) cursor.getLong(1) else -1L- val parent = if (!cursor.isNull(2)) cursor.getString(2) else "<unknown>"- throw IllegalStateException(- "Foreign key violation after provider rebuild: table=$table rowId=$rowId parent=$parent"- )- }- }- }-private fun imageUrlMigrationSql(table: String, column: String): String = """UPDATE $table SET $column = CASEWHEN instr($column, 'streamvault_provider_id=') > 0 THEN $columndiff --git a/data/src/main/java/com/streamvault/data/local/MigrationSupport.kt b/data/src/main/java/com/streamvault/data/local/MigrationSupport.ktindex 93fc5c53..1fc13b82 100644--- a/data/src/main/java/com/streamvault/data/local/MigrationSupport.kt+++ b/data/src/main/java/com/streamvault/data/local/MigrationSupport.kt@@ -3,6 +3,7 @@ package com.streamvault.data.localimport androidx.sqlite.db.SupportSQLiteDatabaseimport org.json.JSONObjectimport java.net.URI+import java.security.MessageDigest/** Shared, reviewable assertions and deterministic backfill helpers for versioned migrations. *//**@@ -109,6 +110,25 @@ internal fun migrationNormalizeOrigin(value: String): String = runCatching {"$scheme://$host:$port${uri.path.orEmpty().trimEnd('/')}"}.getOrElse { value.trim().trimEnd('/').lowercase() }+/** Maps every provider spelling accepted by the legacy runtime to the persisted enum name. */+internal fun canonicalLegacyProviderType(value: String): String = when (value.trim().uppercase()) {+ "XTREAM_CODES", "XTREAM", "XTREAM_CODES_API" -> "XTREAM_CODES"+ "STALKER_PORTAL", "STALKER", "STB" -> "STALKER_PORTAL"+ "JELLYFIN" -> "JELLYFIN"+ "M3U", "PLAYLIST" -> "M3U"+ // ProviderTypeConverter historically treated unrecognized values as playlist providers.+ else -> "M3U"+}++internal fun migrationIdentityKey(parts: List<String>): String =+ MessageDigest.getInstance("SHA-256")+ .digest(parts.joinToString("\u0000").toByteArray(Charsets.UTF_8))+ .joinToString("") { "%02x".format(it) }++/** Keeps a legacy duplicate addressable without violating the new unique identity index. */+internal fun disambiguatedMigrationIdentityKey(canonicalKey: String, providerId: Long): String =+ migrationIdentityKey(listOf(canonicalKey, "legacy-duplicate", providerId.toString()))+internal fun tableHasColumn(database: SupportSQLiteDatabase,tableName: String,diff --git a/data/src/main/java/com/streamvault/data/local/dao/ProviderSnapshotDao.kt b/data/src/main/java/com/streamvault/data/local/dao/ProviderSnapshotDao.ktindex a0ae894b..92bd3eb6 100644--- a/data/src/main/java/com/streamvault/data/local/dao/ProviderSnapshotDao.kt+++ b/data/src/main/java/com/streamvault/data/local/dao/ProviderSnapshotDao.kt@@ -8,6 +8,7 @@ import androidx.room.Transactionimport com.streamvault.data.local.entity.ProviderAccountRuntimeEntityimport com.streamvault.data.local.entity.ProviderConfigEntityimport com.streamvault.data.local.entity.StalkerPortalStateEntity+import com.streamvault.data.local.disambiguatedMigrationIdentityKeyimport kotlinx.coroutines.flow.Flow@Dao@@ -60,9 +61,23 @@ abstract class ProviderSnapshotDao {*/@Transactionopen suspend fun commitConfiguration(entity: ProviderConfigEntity): Boolean {- val current = generation(entity.providerId)- if (current != null && entity.configurationGeneration <= current) return false- upsertConfigDirect(entity)+ val current = getConfig(entity.providerId)+ if (current != null && entity.configurationGeneration <= current.configurationGeneration) return false++ val identityOwner = findProviderIdByIdentityKey(entity.identityKey)+ val entityToWrite = if (identityOwner != null && identityOwner != entity.providerId) {+ // A duplicate preserved by migration has a stable salted identity. Keep it when a+ // later edit computes the canonical key owned by the first legacy provider.+ val migratedIdentity = disambiguatedMigrationIdentityKey(+ canonicalKey = entity.identityKey,+ providerId = entity.providerId+ )+ if (current?.identityKey != migratedIdentity) return false+ entity.copy(identityKey = current.identityKey)+ } else {+ entity+ }+ upsertConfigDirect(entityToWrite)return true}diff --git a/data/src/test/java/com/streamvault/data/local/MigrationSupportTest.kt b/data/src/test/java/com/streamvault/data/local/MigrationSupportTest.ktnew file mode 100644index 00000000..cdaa7a47--- /dev/null+++ b/data/src/test/java/com/streamvault/data/local/MigrationSupportTest.kt@@ -0,0 +1,43 @@+package com.streamvault.data.local++import com.google.common.truth.Truth.assertThat+import org.junit.Test++class MigrationSupportTest {+ @Test+ fun `legacy provider aliases are canonicalized before snapshot backfill`() {+ assertThat(canonicalLegacyProviderType("xtream")).isEqualTo("XTREAM_CODES")+ assertThat(canonicalLegacyProviderType(" XTREAM_CODES_API ")).isEqualTo("XTREAM_CODES")+ assertThat(canonicalLegacyProviderType("stalker")).isEqualTo("STALKER_PORTAL")+ assertThat(canonicalLegacyProviderType("STB")).isEqualTo("STALKER_PORTAL")+ assertThat(canonicalLegacyProviderType("playlist")).isEqualTo("M3U")+ assertThat(canonicalLegacyProviderType("jellyfin")).isEqualTo("JELLYFIN")+ }++ @Test+ fun `unknown legacy provider type follows the runtime M3U fallback`() {+ assertThat(canonicalLegacyProviderType("vendor_specific_playlist"))+ .isEqualTo("M3U")+ }++ @Test+ fun `migration identity hashes canonical components with an unambiguous separator`() {+ assertThat(+ migrationIdentityKey(listOf("XTREAM_CODES", "https://host:443", "alice"))+ ).isEqualTo("771e8fe912c9f1e70aba7cef599dd4c38f68cb208c52174b1774f0ecbe9c3414")+ }++ @Test+ fun `duplicate migration identity is stable and provider specific`() {+ val canonical = migrationIdentityKey(listOf("M3U", "https://host/list.m3u"))++ val first = disambiguatedMigrationIdentityKey(canonical, providerId = 41)+ val same = disambiguatedMigrationIdentityKey(canonical, providerId = 41)+ val otherProvider = disambiguatedMigrationIdentityKey(canonical, providerId = 42)++ assertThat(first).isEqualTo(same)+ assertThat(first).hasLength(64)+ assertThat(first).isNotEqualTo(canonical)+ assertThat(first).isNotEqualTo(otherProvider)+ }+}diff --git a/data/src/test/java/com/streamvault/data/local/ProviderSnapshotDaoTest.kt b/data/src/test/java/com/streamvault/data/local/ProviderSnapshotDaoTest.ktindex 96ce5451..764db746 100644--- a/data/src/test/java/com/streamvault/data/local/ProviderSnapshotDaoTest.kt+++ b/data/src/test/java/com/streamvault/data/local/ProviderSnapshotDaoTest.kt@@ -39,9 +39,7 @@ class ProviderSnapshotDaoTest {ProviderEntity(id = 7,name = "Portal",- type = ProviderType.STALKER_PORTAL,- serverUrl = "https://portal.test",- stalkerMacAddress = "00:11:22:33:44:55"+ type = ProviderType.STALKER_PORTAL))val dao = database.providerSnapshotDao()@@ -75,9 +73,7 @@ class ProviderSnapshotDaoTest {ProviderEntity(id = 7,name = "Portal",- type = ProviderType.STALKER_PORTAL,- serverUrl = "https://portal.test",- stalkerMacAddress = "00:11:22:33:44:55"+ type = ProviderType.STALKER_PORTAL))val dao = database.providerSnapshotDao()@@ -102,12 +98,68 @@ class ProviderSnapshotDaoTest {assertThat(database.stalkerPortalStateDao().get(7)?.workingEndpoint).isEqualTo("new")}- private fun config(generation: Long) = ProviderConfigEntity(- providerId = 7,+ @Test+ fun `new provider cannot replace another provider that owns the canonical identity`() = runTest {+ insertProvider(7, "First")+ insertProvider(8, "Second")+ val dao = database.providerSnapshotDao()+ assertThat(dao.commitConfiguration(config(providerId = 7, generation = 1, identityKey = "canonical")))+ .isTrue()++ assertThat(dao.commitConfiguration(config(providerId = 8, generation = 1, identityKey = "canonical")))+ .isFalse()++ assertThat(dao.getConfig(7)?.identityKey).isEqualTo("canonical")+ assertThat(dao.getConfig(8)).isNull()+ }++ @Test+ fun `migrated duplicate keeps its disambiguated identity when edited`() = runTest {+ insertProvider(7, "First")+ insertProvider(8, "Migrated duplicate")+ val dao = database.providerSnapshotDao()+ dao.commitConfiguration(config(providerId = 7, generation = 1, identityKey = "canonical"))+ val migratedIdentity = disambiguatedMigrationIdentityKey("canonical", providerId = 8)+ dao.commitConfiguration(config(providerId = 8, generation = 1, identityKey = migratedIdentity))++ assertThat(dao.commitConfiguration(config(providerId = 8, generation = 2, identityKey = "canonical")))+ .isTrue()++ assertThat(dao.getConfig(7)?.identityKey).isEqualTo("canonical")+ assertThat(dao.getConfig(8)?.identityKey).isEqualTo(migratedIdentity)+ assertThat(dao.getConfig(8)?.configurationGeneration).isEqualTo(2)+ }++ @Test+ fun `ordinary existing provider cannot change to another providers identity`() = runTest {+ insertProvider(7, "First")+ insertProvider(8, "Second")+ val dao = database.providerSnapshotDao()+ dao.commitConfiguration(config(providerId = 7, generation = 1, identityKey = "first"))+ dao.commitConfiguration(config(providerId = 8, generation = 1, identityKey = "second"))++ assertThat(dao.commitConfiguration(config(providerId = 8, generation = 2, identityKey = "first")))+ .isFalse()+ assertThat(dao.getConfig(8)?.identityKey).isEqualTo("second")+ assertThat(dao.getConfig(8)?.configurationGeneration).isEqualTo(1)+ }++ private suspend fun insertProvider(id: Long, name: String) {+ database.providerDao().insert(+ ProviderEntity(id = id, name = name, type = ProviderType.STALKER_PORTAL)+ )+ }++ private fun config(+ generation: Long,+ providerId: Long = 7,+ identityKey: String = "identity"+ ) = ProviderConfigEntity(+ providerId = providerId,type = ProviderType.STALKER_PORTAL,schemaVersion = 1,configurationGeneration = generation,- identityKey = "identity",+ identityKey = identityKey,encryptedConfigJson = "{}",updatedAt = generation)