StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
test: harden WP0 durable recovery gates
David Nashashce7a3dc52c87
diff --git a/data/src/androidTest/java/com/streamvault/data/manager/recording/PlatformReleaseSafetyInstrumentationTest.kt b/data/src/androidTest/java/com/streamvault/data/manager/recording/PlatformReleaseSafetyInstrumentationTest.ktindex e8eb9c4f..dfbd968e 100644--- a/data/src/androidTest/java/com/streamvault/data/manager/recording/PlatformReleaseSafetyInstrumentationTest.kt+++ b/data/src/androidTest/java/com/streamvault/data/manager/recording/PlatformReleaseSafetyInstrumentationTest.kt@@ -11,6 +11,8 @@ import androidx.work.WorkInfoimport androidx.work.WorkManagerimport androidx.work.testing.WorkManagerTestInitHelperimport com.google.common.truth.Truth.assertThat+import com.streamvault.data.manager.reminder.ProgramReminderRestoreReceiver+import com.streamvault.data.manager.reminder.ProgramReminderRestoreWorkerimport java.util.concurrent.Executorsimport java.util.concurrent.TimeUnitimport org.junit.Before@@ -71,6 +73,38 @@ class PlatformReleaseSafetyInstrumentationTest {assertThat(work).hasSize(1)}+ @Test+ fun bootBroadcastEnqueuesDurableReminderRecovery() {+ sendToReminderRestoreReceiver(Intent(Intent.ACTION_BOOT_COMPLETED))++ val work = workManager+ .getWorkInfosForUniqueWork(ProgramReminderRestoreWorker.ONE_SHOT_WORK_NAME)+ .get(10, TimeUnit.SECONDS)++ assertThat(work).hasSize(1)+ assertThat(work.single().tags).contains(ProgramReminderRestoreWorker::class.java.name)+ }++ @Test+ fun exactAlarmPermissionBroadcastsCoalesceForBothRestorationLanes() {+ val permissionAction = "android.app.action.SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED"+ sendToRecordingRestoreReceiver(Intent(permissionAction))+ sendToRecordingRestoreReceiver(Intent(permissionAction))+ sendToReminderRestoreReceiver(Intent(permissionAction))+ sendToReminderRestoreReceiver(Intent(permissionAction))++ assertThat(+ workManager+ .getWorkInfosForUniqueWork(RECORDING_RECONCILE_ONE_SHOT_WORK_NAME)+ .get(10, TimeUnit.SECONDS)+ ).hasSize(1)+ assertThat(+ workManager+ .getWorkInfosForUniqueWork(ProgramReminderRestoreWorker.ONE_SHOT_WORK_NAME)+ .get(10, TimeUnit.SECONDS)+ ).hasSize(1)+ }+private fun sendToRecordingRestoreReceiver(intent: Intent) {context.sendBroadcast(intent.setComponent(@@ -79,4 +113,13 @@ class PlatformReleaseSafetyInstrumentationTest {)InstrumentationRegistry.getInstrumentation().waitForIdleSync()}++ private fun sendToReminderRestoreReceiver(intent: Intent) {+ context.sendBroadcast(+ intent.setComponent(+ ComponentName(context, ProgramReminderRestoreReceiver::class.java)+ )+ )+ InstrumentationRegistry.getInstrumentation().waitForIdleSync()+ }}diff --git a/data/src/androidTest/java/com/streamvault/data/platform/DataSyncQuotaOwnerInstrumentationTest.kt b/data/src/androidTest/java/com/streamvault/data/platform/DataSyncQuotaOwnerInstrumentationTest.ktnew file mode 100644index 00000000..c43e5aab--- /dev/null+++ b/data/src/androidTest/java/com/streamvault/data/platform/DataSyncQuotaOwnerInstrumentationTest.kt@@ -0,0 +1,60 @@+package com.streamvault.data.platform++import android.content.Context+import androidx.test.core.app.ApplicationProvider+import androidx.test.ext.junit.runners.AndroidJUnit4+import com.google.common.truth.Truth.assertThat+import org.junit.After+import org.junit.Before+import org.junit.Test+import org.junit.runner.RunWith++/** Verifies that the app-wide quota ledger survives a new owner/process boundary. */+@RunWith(AndroidJUnit4::class)+class DataSyncQuotaOwnerInstrumentationTest {++ private lateinit var context: Context++ @Before+ fun setUp() {+ context = ApplicationProvider.getApplicationContext()+ clearLedger()+ }++ @After+ fun tearDown() {+ clearLedger()+ }++ @Test+ fun persistedSessionsAreChargedAndRecoveredByTheNextProcess() {+ val firstProcess = DataSyncQuotaOwner(context)+ val recording = firstProcess.acquire(DataSyncServiceOwner.RECORDING, nowMs = 1_000L)+ .requireGranted()+ firstProcess.acquire(DataSyncServiceOwner.DOWNLOAD, nowMs = 1_000L)+ .requireGranted()++ assertThat(firstProcess.snapshot(nowMs = 4_000L).consumedMs).isEqualTo(6_000L)++ val restartedProcess = DataSyncQuotaOwner(context)+ val recovered = restartedProcess.snapshot(nowMs = 5_000L)++ assertThat(recovered.consumedMs).isEqualTo(8_000L)+ assertThat(recovered.activeOwners).isEmpty()++ // The old lease is intentionally no longer active after restart; releasing it must be+ // harmless and must not debit the next process's ledger a second time.+ val afterLateRelease = restartedProcess.release(recording, nowMs = 6_000L)+ assertThat(afterLateRelease.consumedMs).isEqualTo(8_000L)+ }++ private fun clearLedger() {+ context.getSharedPreferences("foreground_service_quota", Context.MODE_PRIVATE)+ .edit()+ .clear()+ .commit()+ }++ private fun DataSyncQuotaAcquireResult.requireGranted(): DataSyncQuotaLease =+ (this as DataSyncQuotaAcquireResult.Granted).lease+}diff --git a/data/src/main/java/com/streamvault/data/manager/reminder/ProgramReminderRestoreReceiver.kt b/data/src/main/java/com/streamvault/data/manager/reminder/ProgramReminderRestoreReceiver.ktindex 2ceb3f8d..6072a3a5 100644--- a/data/src/main/java/com/streamvault/data/manager/reminder/ProgramReminderRestoreReceiver.kt+++ b/data/src/main/java/com/streamvault/data/manager/reminder/ProgramReminderRestoreReceiver.kt@@ -4,42 +4,15 @@ import android.content.BroadcastReceiverimport android.content.Contextimport android.content.Intentimport android.app.AlarmManager-import com.streamvault.data.manager.ProgramReminderManagerImpl-import dagger.hilt.EntryPoint-import dagger.hilt.InstallIn-import dagger.hilt.android.EntryPointAccessors-import dagger.hilt.components.SingletonComponent-import kotlinx.coroutines.CoroutineScope-import kotlinx.coroutines.Dispatchers-import kotlinx.coroutines.SupervisorJob-import kotlinx.coroutines.launchclass ProgramReminderRestoreReceiver : BroadcastReceiver() {- @EntryPoint- @InstallIn(SingletonComponent::class)- interface ProgramReminderRestoreReceiverEntryPoint {- fun reminderManager(): ProgramReminderManagerImpl- }-override fun onReceive(context: Context, intent: Intent) {when (intent.action) {Intent.ACTION_BOOT_COMPLETED,Intent.ACTION_MY_PACKAGE_REPLACED,AlarmManager.ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED -> {- val pendingResult = goAsync()- val appContext = context.applicationContext- CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {- try {- val entryPoint = EntryPointAccessors.fromApplication(- appContext,- ProgramReminderRestoreReceiverEntryPoint::class.java- )- entryPoint.reminderManager().restoreScheduledReminders()- } finally {- pendingResult.finish()- }- }+ ProgramReminderRestoreWorker.enqueueOneShot(context)}}}diff --git a/data/src/main/java/com/streamvault/data/manager/reminder/ProgramReminderRestoreWorker.kt b/data/src/main/java/com/streamvault/data/manager/reminder/ProgramReminderRestoreWorker.ktnew file mode 100644index 00000000..69d24e84--- /dev/null+++ b/data/src/main/java/com/streamvault/data/manager/reminder/ProgramReminderRestoreWorker.kt@@ -0,0 +1,60 @@+package com.streamvault.data.manager.reminder++import android.content.Context+import androidx.work.BackoffPolicy+import androidx.work.CoroutineWorker+import androidx.work.ExistingWorkPolicy+import androidx.work.OneTimeWorkRequestBuilder+import androidx.work.WorkManager+import androidx.work.WorkerParameters+import com.streamvault.data.manager.ProgramReminderManagerImpl+import dagger.hilt.EntryPoint+import dagger.hilt.InstallIn+import dagger.hilt.android.EntryPointAccessors+import dagger.hilt.components.SingletonComponent+import java.util.concurrent.TimeUnit+import kotlinx.coroutines.CancellationException++/** Durable startup and exact-alarm-permission restoration for program reminders. */+class ProgramReminderRestoreWorker(+ appContext: Context,+ workerParams: WorkerParameters+) : CoroutineWorker(appContext, workerParams) {++ @EntryPoint+ @InstallIn(SingletonComponent::class)+ interface ProgramReminderRestoreWorkerEntryPoint {+ fun reminderManager(): ProgramReminderManagerImpl+ }++ override suspend fun doWork(): Result = try {+ EntryPointAccessors.fromApplication(+ applicationContext,+ ProgramReminderRestoreWorkerEntryPoint::class.java+ ).reminderManager().restoreScheduledReminders()+ Result.success()+ } catch (error: Exception) {+ if (error is CancellationException) throw error+ Result.retry()+ }++ companion object {+ internal const val ONE_SHOT_WORK_NAME = "ProgramReminderRestoreWorkerOneShot"+ private const val BACKOFF_MILLIS = 30_000L++ fun enqueueOneShot(context: Context) {+ val request = OneTimeWorkRequestBuilder<ProgramReminderRestoreWorker>()+ .setBackoffCriteria(+ BackoffPolicy.EXPONENTIAL,+ BACKOFF_MILLIS,+ TimeUnit.MILLISECONDS+ )+ .build()+ WorkManager.getInstance(context).enqueueUniqueWork(+ ONE_SHOT_WORK_NAME,+ ExistingWorkPolicy.KEEP,+ request+ )+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/platform/DataSyncQuotaOwner.kt b/data/src/main/java/com/streamvault/data/platform/DataSyncQuotaOwner.ktindex 6abbda6e..fe431334 100644--- a/data/src/main/java/com/streamvault/data/platform/DataSyncQuotaOwner.kt+++ b/data/src/main/java/com/streamvault/data/platform/DataSyncQuotaOwner.kt@@ -120,7 +120,9 @@ class DataSyncQuotaOwner @Inject constructor(.put(KEY_PROCESS_ID, session.processId))}- preferences.edit {+ // Lease acquisition/release is release-gate state. Commit synchronously so a process kill+ // cannot lose the ledger update that is needed to reconcile the next process.+ preferences.edit(commit = true) {putLong(KEY_WINDOW_STARTED_AT, ledger.windowStartedAtMs)putLong(KEY_CONSUMED_MS, ledger.consumedMs)putString(KEY_SESSIONS, sessions.toString())