Skip to content

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

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.kt
index 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.WorkInfo
import androidx.work.WorkManager
import androidx.work.testing.WorkManagerTestInitHelper
import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.manager.reminder.ProgramReminderRestoreReceiver
+import com.streamvault.data.manager.reminder.ProgramReminderRestoreWorker
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import 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.kt
new file mode 100644
index 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.kt
index 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.BroadcastReceiver
import android.content.Context
import android.content.Intent
import 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.launch
class 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.kt
new file mode 100644
index 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.kt
index 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())