Skip to content

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

feat: implement database startup coordination and migration handling

David Nashashc4f112cf349f
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index bb027d16..8b9ddf59 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -57,8 +57,8 @@ android {
applicationId = "com.streamvault.app"
minSdk = 25
targetSdk = 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"] = expectedApi
diff --git a/app/src/main/java/com/streamvault/app/DatabaseStartupGate.kt b/app/src/main/java/com/streamvault/app/DatabaseStartupGate.kt
new file mode 100644
index 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.kt
index 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.PreferencesRepository
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import 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.dp
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalLayoutDirection
import androidx.compose.runtime.CompositionLocalProvider
@@ -57,6 +73,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
+import com.streamvault.app.diagnostics.CrashReportStore
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
@@ -105,6 +122,9 @@ class MainActivity : ComponentActivity() {
@Inject
lateinit 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 = isInPictureInPictureMode
handleExternalIntent(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.current
val 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.kt
index 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.app
import android.app.Application
+import android.util.Log
import coil3.ImageLoader
import coil3.PlatformContext
import coil3.SingletonImageLoader
@@ -20,6 +21,8 @@ import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.flow.first
import okio.Path.Companion.toOkioPath
import androidx.work.Constraints
@@ -65,6 +68,9 @@ class StreamVaultApp : Application(), SingletonImageLoader.Factory {
@Inject
lateinit 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.kt
index 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.kt
new file mode 100644
index 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.kt
index 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()
+ }
+
@Test
fun 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.kt
index 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.Migration
import androidx.sqlite.db.SupportSQLiteDatabase
import org.json.JSONObject
import 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 = CASE
WHEN instr($column, 'streamvault_provider_id=') > 0 THEN $column
diff --git a/data/src/main/java/com/streamvault/data/local/MigrationSupport.kt b/data/src/main/java/com/streamvault/data/local/MigrationSupport.kt
index 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.local
import androidx.sqlite.db.SupportSQLiteDatabase
import org.json.JSONObject
import 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.kt
index 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.Transaction
import com.streamvault.data.local.entity.ProviderAccountRuntimeEntity
import com.streamvault.data.local.entity.ProviderConfigEntity
import com.streamvault.data.local.entity.StalkerPortalStateEntity
+import com.streamvault.data.local.disambiguatedMigrationIdentityKey
import kotlinx.coroutines.flow.Flow
@Dao
@@ -60,9 +61,23 @@ abstract class ProviderSnapshotDao {
*/
@Transaction
open 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.kt
new file mode 100644
index 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.kt
index 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
)