From 169349244779af9e587c9a2b8c4747fb72529bfc Mon Sep 17 00:00:00 2001 From: max rovkin Date: Mon, 31 Aug 2026 21:13:44 +0500 Subject: [PATCH 1/3] Add hermetic video player tests --- app/build.gradle.kts | 10 + app/src/androidTest/AndroidManifest.xml | 4 + .../player/component/PlayerScreenE2ETest.kt | 1200 +++++++++++++++++ .../player/vm/PlaybackControllerDeviceTest.kt | 444 ++++++ .../vm/PlaybackControllerNetworkTracksTest.kt | 860 ++++++++++++ .../vm/PlaybackControllerResourcesTest.kt | 752 +++++++++++ .../puber/profile/BaselineNetworkBlocker.kt | 146 +- .../profile/BaselineProfileControlReceiver.kt | 2 +- .../kino/puber/profile/PlayerTestControl.kt | 100 ++ .../java/com/kino/puber/core/ui/PuberVM.kt | 28 +- .../player/component/PlayerControlsOverlay.kt | 1 + .../player/component/PlayerProgressBar.kt | 11 + .../feature/player/component/PlayerScreen.kt | 5 +- .../ui/feature/player/vm/Ac3FallbackPolicy.kt | 25 + .../feature/player/vm/ControlsStateMachine.kt | 11 + .../feature/player/vm/PlaybackCallbackGate.kt | 38 + .../feature/player/vm/PlaybackController.kt | 182 +-- .../player/vm/PlaybackMediaItemFactory.kt | 40 + .../puber/ui/feature/player/vm/PlayerVM.kt | 44 +- .../data/api/MockWebServerTestSupport.kt | 36 +- .../player/vm/Ac3FallbackPolicyTest.kt | 34 + .../vm/AudioTrackPreferenceResolverTest.kt | 64 + .../feature/player/vm/HlsErrorPolicyTest.kt | 105 ++ ...laybackControllerCallbackGenerationTest.kt | 175 +++ .../player/vm/PlaybackMediaItemFactoryTest.kt | 57 + .../vm/PlayerVMCallbackGenerationTest.kt | 183 +++ .../ui/feature/player/vm/PlayerVMTest.kt | 18 + .../player/vm/SubtitleTrackIdentityTest.kt | 33 + baselineprofile/build.gradle.kts | 1 + baselineprofile/src/main/AndroidManifest.xml | 4 + .../baselineprofile/BaselineMockBackend.kt | 99 +- build.gradle.kts | 3 +- docs/testing/player-playback.md | 230 ++++ gradle/libs.versions.toml | 5 + player-test-fixtures/SHA256SUMS | 20 + player-test-fixtures/build.gradle.kts | 36 + player-test-fixtures/fixtures-provenance.md | 8 + .../PlayerTestFixturesAndroidTest.kt | 27 + .../main/assets/player-fixtures/SHA256SUMS | 20 + .../fixture-manifest.properties | 19 + .../player-fixtures/hls/audio_english.m3u8 | 12 + .../player-fixtures/hls/audio_english_000.ts | Bin 0 -> 26884 bytes .../player-fixtures/hls/audio_english_001.ts | Bin 0 -> 26508 bytes .../player-fixtures/hls/audio_english_002.ts | Bin 0 -> 940 bytes .../player-fixtures/hls/audio_spanish.m3u8 | 12 + .../player-fixtures/hls/audio_spanish_000.ts | Bin 0 -> 26696 bytes .../player-fixtures/hls/audio_spanish_001.ts | Bin 0 -> 26508 bytes .../player-fixtures/hls/audio_spanish_002.ts | Bin 0 -> 940 bytes .../assets/player-fixtures/hls/master.m3u8 | 9 + .../assets/player-fixtures/hls/video_360.m3u8 | 11 + .../player-fixtures/hls/video_360_000.ts | Bin 0 -> 178412 bytes .../player-fixtures/hls/video_360_001.ts | Bin 0 -> 195520 bytes .../assets/player-fixtures/hls/video_720.m3u8 | 11 + .../player-fixtures/hls/video_720_000.ts | Bin 0 -> 320164 bytes .../player-fixtures/hls/video_720_001.ts | Bin 0 -> 404388 bytes .../assets/player-fixtures/progressive.mp4 | Bin 0 -> 458791 bytes .../main/assets/player-fixtures/subtitle.vtt | 4 + .../playertestfixtures/PlayerTestFixtures.kt | 118 ++ .../network/LoopbackNetworkBlocker.kt | 59 + .../network/LoopbackNetworkJournal.kt | 75 ++ .../server/HermeticRequestJournal.kt | 120 ++ .../server/HermeticTestServer.kt | 522 +++++++ .../PlayerTestFixturesTest.kt | 116 ++ .../server/HermeticTestServerTest.kt | 311 +++++ settings.gradle.kts | 3 +- tools/generate-player-test-fixtures.sh | 200 +++ tools/resolve-android-test-apk-pair | 171 +++ tools/test-resolve-android-test-apk-pair | 159 +++ 68 files changed, 6647 insertions(+), 346 deletions(-) create mode 100644 app/src/androidTest/AndroidManifest.xml create mode 100644 app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt create mode 100644 app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt create mode 100644 app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt create mode 100644 app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt create mode 100644 app/src/instrumentation/java/com/kino/puber/profile/PlayerTestControl.kt create mode 100644 app/src/main/java/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicy.kt create mode 100644 app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackCallbackGate.kt create mode 100644 app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt create mode 100644 app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicyTest.kt create mode 100644 app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt create mode 100644 app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/HlsErrorPolicyTest.kt create mode 100644 app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt create mode 100644 app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt create mode 100644 app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt create mode 100644 app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentityTest.kt create mode 100644 baselineprofile/src/main/AndroidManifest.xml create mode 100644 docs/testing/player-playback.md create mode 100644 player-test-fixtures/SHA256SUMS create mode 100644 player-test-fixtures/build.gradle.kts create mode 100644 player-test-fixtures/fixtures-provenance.md create mode 100644 player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/SHA256SUMS create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/fixture-manifest.properties create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english.m3u8 create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english_000.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english_001.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english_002.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish.m3u8 create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_000.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_001.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_002.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/master.m3u8 create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/video_360.m3u8 create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/video_360_000.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/video_360_001.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/video_720.m3u8 create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/video_720_000.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/hls/video_720_001.ts create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/progressive.mp4 create mode 100644 player-test-fixtures/src/main/assets/player-fixtures/subtitle.vtt create mode 100644 player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt create mode 100644 player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkBlocker.kt create mode 100644 player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkJournal.kt create mode 100644 player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticRequestJournal.kt create mode 100644 player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServer.kt create mode 100644 player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt create mode 100644 player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServerTest.kt create mode 100755 tools/generate-player-test-fixtures.sh create mode 100755 tools/resolve-android-test-apk-pair create mode 100755 tools/test-resolve-android-test-apk-pair diff --git a/app/build.gradle.kts b/app/build.gradle.kts index c9e02e92..b34fa568 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -298,23 +298,33 @@ dependencies { // Testing testImplementation(libs.junit5) + testImplementation(libs.junit) testRuntimeOnly(libs.junit5.launcher) + testRuntimeOnly(libs.junit5.vintage) testImplementation(libs.coroutines.test) testImplementation(libs.mockk) + testImplementation(libs.robolectric) testImplementation(libs.ktor.client.mock) testImplementation(libs.mockwebserver3) + testImplementation(project(":player-test-fixtures")) detektPlugins(libs.detekt.compose.rules) androidTestImplementation(platform(libs.androidx.compose.bom)) androidTestImplementation(libs.androidx.ui.test.junit4) androidTestImplementation(libs.mockwebserver3) + add("instrumentationImplementation", project(":player-test-fixtures")) + add("instrumentationImplementation", libs.mockwebserver3) debugImplementation(libs.androidx.ui.tooling) debugImplementation(libs.androidx.ui.test.manifest) implementation(libs.androidx.profileinstaller) } +android.testOptions { + unitTests.isIncludeAndroidResources = true +} + baselineProfile { saveInSrc = true automaticGenerationDuringBuild = false diff --git a/app/src/androidTest/AndroidManifest.xml b/app/src/androidTest/AndroidManifest.xml new file mode 100644 index 00000000..72559ce3 --- /dev/null +++ b/app/src/androidTest/AndroidManifest.xml @@ -0,0 +1,4 @@ + diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt new file mode 100644 index 00000000..ceb9a805 --- /dev/null +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt @@ -0,0 +1,1200 @@ +package com.kino.puber.ui.feature.player.component + +import android.app.Activity +import android.view.View +import android.view.ViewGroup +import android.view.KeyEvent as AndroidKeyEvent +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.compose.runtime.Composable +import androidx.compose.ui.semantics.SemanticsNode +import androidx.compose.ui.semantics.SemanticsActions +import androidx.compose.ui.semantics.SemanticsProperties +import androidx.compose.ui.semantics.getOrNull +import androidx.compose.ui.test.SemanticsMatcher +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.assertIsFocused +import androidx.compose.ui.test.getUnclippedBoundsInRoot +import androidx.compose.ui.test.hasAnyDescendant +import androidx.compose.ui.test.hasText +import androidx.compose.ui.test.isFocused +import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule +import androidx.compose.ui.test.onAllNodesWithText +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.onRoot +import androidx.lifecycle.Lifecycle +import androidx.media3.common.C +import androidx.media3.common.Player +import androidx.media3.common.util.UnstableApi +import androidx.media3.ui.PlayerView +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import androidx.tv.material3.Text +import com.kino.puber.R +import com.kino.puber.core.ui.navigation.AppLauncher +import com.kino.puber.core.ui.navigation.AppRouter +import com.kino.puber.core.ui.navigation.PuberScreen +import com.kino.puber.core.ui.navigation.Screens +import com.kino.puber.core.ui.navigation.component.FlowComponent +import com.kino.puber.core.ui.uikit.theme.PuberTheme +import com.kino.puber.data.api.models.ItemType +import com.kino.puber.data.repository.PlayerPreferencesRepository +import com.kino.puber.playertestfixtures.FixtureId +import com.kino.puber.playertestfixtures.PlayerTestFixtures +import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal +import com.kino.puber.playertestfixtures.server.HermeticRoute +import com.kino.puber.playertestfixtures.server.HermeticTestServer +import com.kino.puber.playertestfixtures.server.QueryMatchMode +import com.kino.puber.playertestfixtures.server.ResponsePlan +import com.kino.puber.profile.PlayerTestControl +import com.kino.puber.ui.ScreensImpl +import com.kino.puber.ui.feature.player.model.PlayerScreenParams +import com.kino.puber.ui.feature.player.model.PlayerStartMode +import java.util.UUID +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicInteger +import java.util.concurrent.atomic.AtomicReference +import kotlinx.parcelize.Parcelize +import mockwebserver3.RecordedRequest +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Assert.fail +import org.junit.Before +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.koin.core.context.GlobalContext +import org.koin.core.qualifier.named +import org.koin.dsl.module + +/** + * Production-screen coverage. Every case launches the real [PlayerScreen] + * through the same FlowComponent and screen Koin scope used by the app. + */ +@OptIn(UnstableApi::class) +@RunWith(AndroidJUnit4::class) +internal class PlayerScreenE2ETest { + + @get:Rule + val composeRule = createAndroidComposeRule() + + private val instrumentation + get() = InstrumentationRegistry.getInstrumentation() + + private val context + get() = instrumentation.targetContext + + private lateinit var server: PlayerTestControl + private lateinit var scenarioToken: String + private lateinit var flowScopeName: String + private lateinit var currentScreen: PlayerScreen + private var currentItemId: Int = 0 + private val ownedItemIds = mutableSetOf() + + @Before + fun setUp() { + LoopbackNetworkJournal(context).clear() + RecordingAppLauncher.reset() + scenarioToken = UUID.randomUUID().toString() + server = PlayerTestControl() + server.start() + } + + @After + fun tearDown() { + var teardownFailure: Throwable? = null + runCatching { + if (composeRule.activityRule.scenario.state != Lifecycle.State.DESTROYED) { + composeRule.activityRule.scenario.moveToState(Lifecycle.State.RESUMED) + composeRule.activityRule.scenario.onActivity { activity -> + activity.setContent {} + } + composeRule.waitForIdle() + } + }.onFailure { teardownFailure = it } + + ownedItemIds.forEach { itemId -> + PlayerPreferencesRepository(context).saveTrackPreferences( + itemId = itemId, + audioLang = null, + audioLabel = null, + subtitleLang = null, + subtitleUrl = null, + ) + } + + if (::server.isInitialized) { + try { + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + server.assertNoUnknownRequests() + } catch (error: Throwable) { + teardownFailure = teardownFailure ?: error + } finally { + server.close() + } + } + + val egress = LoopbackNetworkJournal(context).snapshot() + if (egress.isNotEmpty()) { + teardownFailure = teardownFailure ?: AssertionError("Unexpected network egress: $egress") + } + RecordingAppLauncher.reset() + teardownFailure?.let { throw it } + } + + @Test + fun movieScreen_realRemoteControlsPanelsAndRecreation_restoreFocusTracksAndMediaState() { + val itemId = 7901 + val media = MovieMediaRoots(itemId) + server.reset(movieRoutes(itemId, watchingTime = 0, media = media)) + launchPlayer( + itemId = itemId, + startMode = PlayerStartMode.StartFromBeginning, + ) + + assertFocusedPlayPause() + awaitPlayerReady() + awaitPlayerCondition("initial movie position advances") { + playerPosition() >= POSITION_FENCE_MS + } + + pressBack() + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("media key pauses playback") { + !playerIsPlaying() + } + assertFocusedPlayPause() + pressBack() + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("media key resumes playback") { + playerIsPlaying() + } + assertFocusedPlayPause() + pressBack() + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("second media key pauses playback") { + !playerIsPlaying() + } + assertFocusedPlayPause() + + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_UP) + assertFocusedSeekBar() + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) + assertFocusedPlayPause() + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_mark_watched)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) + + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + assertFocusedText(context.getString(R.string.player_sound_stereo)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(ENGLISH_AUDIO_LABEL) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) + assertFocusedText(SPANISH_AUDIO_LABEL) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerCondition("Spanish audio is selected in UI state and Media3") { + selectedAudioLanguage() == SPANISH_LANGUAGE && + preferredAudioLanguage() == SPANISH_LANGUAGE + } + + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(SUBTITLE_LANGUAGE) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerCondition("external subtitle is persisted and selected in Media3") { + preferredSubtitleLanguage() == SUBTITLE_LANGUAGE && + selectedTextTrack() && + preferredTextLanguages().contains(SUBTITLE_LANGUAGE) + } + pressBack() + assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) + assertFocusedText(context.getString(R.string.player_button_mark_watched)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) + assertFocusedPlayPause() + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerCondition("selected external subtitle loads during playback") { + playerIsPlaying() + } + awaitJournalPath("${media.high}/subtitle.vtt") + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerCondition("playback pauses after external subtitle request") { + !playerIsPlaying() + } + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_mark_watched)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_video)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + assertFocusedText(context.getString(R.string.player_aspect_auto)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) + assertFocusedText(HIGH_QUALITY_LABEL) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) + assertFocusedText(LOW_QUALITY_LABEL) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerCondition("manual quality changes the production Media3 item") { + currentMediaPath() == "${media.low}/master.m3u8" + } + awaitJournalPath("${media.low}/master.m3u8") + + pressBack() + assertFocusedText(context.getString(R.string.player_button_video)) + pressBack() + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) + assertFocusedPlayPause() + + val previousActivity = AtomicReference() + composeRule.activityRule.scenario.onActivity(previousActivity::set) + composeRule.activityRule.scenario.recreate() + setPlayerContent() + composeRule.activityRule.scenario.onActivity { recreatedActivity -> + assertTrue( + "ActivityScenario.recreate must replace the host activity", + recreatedActivity !== previousActivity.get(), + ) + } + assertFocusedPlayPause() + awaitPlayerReady() + awaitPlayerCondition("recreated UI state restores audio and subtitle choices") { + preferredAudioLanguage() == SPANISH_LANGUAGE && + preferredSubtitleLanguage() == SUBTITLE_LANGUAGE + } + awaitPlayerCondition("recreated Media3 restores audio and subtitle choices") { + selectedAudioLanguage() == SPANISH_LANGUAGE && + selectedTextTrack() && + preferredTextLanguages().contains(SUBTITLE_LANGUAGE) + } + + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_mark_watched)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + assertFocusedText(context.getString(R.string.player_button_video)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + assertFocusedText(context.getString(R.string.player_aspect_auto)) + pressBack() + assertFalse( + "Video-settings panel Back must not pop PlayerScreen after recreation", + isTextDisplayed(HOST_TEXT), + ) + assertFocusedText(context.getString(R.string.player_button_video)) + + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) + assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + assertFocusedText(context.getString(R.string.player_sound_stereo)) + assertEquals(SPANISH_LANGUAGE, preferredAudioLanguage()) + assertEquals(SUBTITLE_LANGUAGE, preferredSubtitleLanguage()) + pressBack() + assertFalse( + "Audio/subtitle panel Back must not pop PlayerScreen after recreation", + isTextDisplayed(HOST_TEXT), + ) + assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) + + pressBack() + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("recreated playback starts or replays before seek checks") { + playerIsPlaying() && playerPosition() >= POSITION_FENCE_MS + } + assertFocusedPlayPause() + pressBack() + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("recreated playback pauses from the player surface") { + !playerIsPlaying() && playerPosition() >= POSITION_FENCE_MS + } + assertFocusedPlayPause() + pressBack() + assertFocusedPlayerSurface() + val beforeBackwardSeek = playerPosition() + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) + awaitPlayerCondition("D-pad left seeks backward") { + playerPosition() < beforeBackwardSeek + } + awaitText(context.getString(R.string.player_seek_backward, SEEK_STEP_SECONDS)) + assertFocusedPlayerSurface() + val beforeForwardSeek = playerPosition() + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) + awaitPlayerCondition("D-pad right seeks forward") { + playerPosition() > beforeForwardSeek + } + awaitText(context.getString(R.string.player_seek_forward, SEEK_STEP_SECONDS)) + assertFocusedPlayerSurface() + assertEquals(0, server.requestJournal.unknownRequests.size) + + pressBack() + awaitPlayerCondition("recreated PlayerScreen exits on the unchanged second Back") { + isTextDisplayed(HOST_TEXT) + } + } + + @Test + fun movieScreen_continueCrossesSavedFence_andSeparatesPauseBackgroundAndExitSaves() { + val itemId = 7902 + val media = MovieMediaRoots(itemId) + server.reset(movieRoutes(itemId, watchingTime = SAVED_POSITION_SECONDS, media = media)) + launchPlayer(itemId) + + assertFocusedText(context.getString(R.string.player_resume_continue)) + assertTrue(playerPosition() < SAVED_POSITION_FENCE_MS) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerCondition("Continue crosses the saved-position fence") { + playerPosition() >= SAVED_POSITION_FENCE_MS + } + assertFocusedPlayerSurface() + + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("pause is observable before its save") { + !playerIsPlaying() + } + assertFocusedPlayPause() + val pauseSave = awaitProgressRequest("pause progress save", itemId, video = 1, season = null) + assertProgressTimeAtLeast(pauseSave, MIN_SAVED_TIME_SECONDS) + + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerCondition("play resumes before background") { + playerIsPlaying() + } + composeRule.activityRule.scenario.moveToState(Lifecycle.State.CREATED) + val backgroundSave = awaitProgressRequest( + "background progress save", + itemId, + video = 1, + season = null, + ) + assertProgressTimeAtLeast(backgroundSave, MIN_SAVED_TIME_SECONDS) + + composeRule.activityRule.scenario.moveToState(Lifecycle.State.RESUMED) + setPlayerContentIfMissing() + awaitPlayerCondition("background keeps the player paused") { + !playerIsPlaying() + } + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("play resumes before exit") { + playerIsPlaying() + } + assertFocusedPlayPause() + + pressBack() + assertFocusedPlayerSurface() + pressBack() + val exitSave = awaitProgressRequest("exit progress save", itemId, video = 1, season = null) + assertProgressTimeAtLeast(exitSave, MIN_SAVED_TIME_SECONDS) + awaitPlayerCondition("Back exits only after the final progress write drains") { + isTextDisplayed(HOST_TEXT) + } + + assertTrue(pauseSave !== backgroundSave) + assertTrue(backgroundSave !== exitSave) + } + + @Test + fun movieScreen_failedMedia_focusesRetry_recoversAndBackDrainsProgressBeforeExit() { + val itemId = 7903 + val media = MovieMediaRoots(itemId) + server.reset(retryMovieRoutes(itemId, media)) + launchPlayer( + itemId = itemId, + startMode = PlayerStartMode.StartFromBeginning, + ) + + assertFocusedPlayPause() + assertFocusedTextEventually(context.getString(R.string.player_error_retry)) + assertEquals(RETRY_FAILURE_REQUESTS, routeRequestCount(media.high, "master")) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + awaitPlayerReady() + awaitPlayerCondition("Retry reaches real playback") { + playerIsPlaying() && currentMediaPath() == "${media.high}/master.m3u8" + } + assertTrue(routeRequestCount(media.high, "master") > RETRY_FAILURE_REQUESTS) + + assertFocusedPlayPause() + pressBack() + assertFocusedPlayerSurface() + pressBack() + awaitProgressRequest("Retry journey exit save", itemId, video = 1, season = null) + awaitPlayerCondition("Back exits recovered playback") { + isTextDisplayed(HOST_TEXT) + } + } + + @Test + fun seriesScreen_nextEpisodeDpadJourney_usesDistinctRoutesAndEpisodeProgressIdentity() { + val itemId = 7904 + val media = SeriesMediaRoots(itemId) + server.reset(seriesRoutes(itemId, media)) + launchPlayer( + itemId = itemId, + seasonNumber = 1, + episodeNumber = 1, + startMode = PlayerStartMode.StartFromBeginning, + ) + + assertFocusedPlayPause() + awaitPlayerReady() + awaitJournalPath("${media.episodeOne}/master.m3u8") + assertFocusedTextEventually( + text = context.getString(R.string.player_next_episode_countdown, 15) + .substringBefore("15"), + substring = true, + ) + sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) + + val firstEpisodeSave = awaitProgressRequest( + "first episode transition save", + itemId, + video = 1, + season = 1, + ) + assertNull(firstEpisodeSave.url.queryParameter("episode")) + awaitJournalPath("${media.episodeTwo}/master.m3u8") + awaitPlayerCondition("second episode owns the active production player") { + currentMediaPath() == "${media.episodeTwo}/master.m3u8" + } + awaitText(context.getString(R.string.player_season_episode_title, 1, 2, "Second episode")) + awaitPlayerReady() + + if (isTextDisplayed(context.getString(R.string.player_button_audio_subtitles))) { + pressBack() + } + assertFocusedPlayerSurface() + sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) + awaitPlayerCondition("second episode pause is observable") { + !playerIsPlaying() + } + val secondEpisodeSave = awaitProgressRequest( + "second episode pause save", + itemId, + video = 2, + season = 1, + ) + assertNull(secondEpisodeSave.url.queryParameter("episode")) + + assertTrue( + "Expected distinct episode media routes: ${server.requestJournal.entries}", + server.requestJournal.entries.any { it.path == "${media.episodeOne}/master.m3u8" } && + server.requestJournal.entries.any { it.path == "${media.episodeTwo}/master.m3u8" }, + ) + assertEquals("1", firstEpisodeSave.url.queryParameter("video")) + assertEquals("2", secondEpisodeSave.url.queryParameter("video")) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + private fun launchPlayer( + itemId: Int, + seasonNumber: Int? = null, + episodeNumber: Int? = null, + startMode: PlayerStartMode = PlayerStartMode.ResumeIfAvailable, + ) { + ownedItemIds += itemId + currentItemId = itemId + flowScopeName = "PlayerScreenE2ETest:$itemId:$scenarioToken" + currentScreen = PlayerScreen( + PlayerScreenParams( + itemId = itemId, + seasonNumber = seasonNumber, + episodeNumber = episodeNumber, + startMode = startMode, + ), + ) + setPlayerContent() + composeRule.waitUntil(PLAYER_TIMEOUT_MS) { + server.requestJournal.entries.any { it.path == "/v1/items/$itemId" } + } + awaitPlayerCondition("production UI player for item $itemId") { + uiPlayerRead { playbackState } != null + } + } + + private fun setPlayerContent() { + composeRule.activityRule.scenario.onActivity { activity -> + activity.setContent { + PuberTheme { + FlowComponent( + scopeName = flowScopeName, + screen = PlayerE2EHostScreen, + moduleFactory = { scopeId, _ -> + module { + scope(named(scopeId)) { + scoped { RecordingAppLauncher } + scoped { ScreensImpl } + } + } + }, + ) + } + } + } + composeRule.waitForIdle() + composeRule.waitUntil(FOCUS_TIMEOUT_MS) { + GlobalContext.get().getScopeOrNull(flowScopeName) != null + } + if (GlobalContext.get().getScopeOrNull(playerScopeId()) == null) { + onMain { flowRouter().navigateTo(currentScreen) } + composeRule.waitForIdle() + } + } + + private fun setPlayerContentIfMissing() { + if (runCatching { uiPlayerRead { playbackState } }.getOrNull() == null) { + setPlayerContent() + } + } + + private fun flowRouter(): AppRouter { + val scope = GlobalContext.get().getScopeOrNull(flowScopeName) + ?: error("Missing flow scope $flowScopeName") + return scope.get() + } + + private fun playerScopeId(): String { + val screenKey = currentScreen.key + return "currentScreen$flowScopeName$screenKey:$screenKey" + } + + private fun preferredAudioLanguage(): String? = + PlayerPreferencesRepository(context).getPreferredAudioLang(currentItemId) + + private fun preferredSubtitleLanguage(): String? = + PlayerPreferencesRepository(context).getPreferredSubtitleLang(currentItemId) + + private fun playerPosition(): Long = uiPlayerRead { currentPosition } ?: 0L + + private fun playerIsPlaying(): Boolean = uiPlayerRead { isPlaying } == true + + private fun currentMediaPath(): String? = + uiPlayerRead { currentMediaItem?.localConfiguration?.uri?.encodedPath } + + private fun selectedAudioLanguage(): String? = uiPlayerRead { + currentTracks + .groups + .filter { it.type == C.TRACK_TYPE_AUDIO } + .firstOrNull { it.isSelected } + ?.getTrackFormat(0) + ?.language + } + + private fun selectedTextTrack(): Boolean = uiPlayerRead { + currentTracks + .groups + .filter { it.type == C.TRACK_TYPE_TEXT } + .any { it.isSelected } + } == true + + private fun preferredTextLanguages(): List = + uiPlayerRead { trackSelectionParameters.preferredTextLanguages.toList() }.orEmpty() + + private fun awaitPlayerReady() { + awaitPlayerCondition("Media3 READY without PlayerScreen error") { + uiPlayerRead { playbackState } == Player.STATE_READY + } + } + + private fun awaitPlayerCondition( + label: String, + condition: () -> Boolean, + ) { + try { + composeRule.waitUntil(PLAYER_TIMEOUT_MS) { + runCatching(condition).getOrDefault(false) + } + } catch (error: Throwable) { + throw AssertionError("$label was not reached; diagnostics=${diagnostics()}", error) + } + } + + private fun diagnostics(): String { + val player = runCatching { + uiPlayerRead { + "state=$playbackState,playing=$isPlaying," + + "position=$currentPosition,duration=$duration," + + "media=${currentMediaItem?.localConfiguration?.uri?.encodedPath}," + + "textSelected=${currentTracks.groups.any { group -> + group.type == C.TRACK_TYPE_TEXT && group.isSelected + }},preferredText=${trackSelectionParameters.preferredTextLanguages}," + + "savedSubtitle=${preferredSubtitleLanguage()}" + } + }.getOrNull() + return "player=$player,requests=${server.requestJournal.entries.takeLast(16)}" + } + + private fun uiPlayerRead(read: Player.() -> T): T? { + val result = AtomicReference?>(null) + composeRule.activityRule.scenario.onActivity { activity -> + result.set( + runCatching { + activity.window.decorView.findPlayerView()?.player?.read() + }, + ) + } + return requireNotNull(result.get()).getOrThrow() + } + + private fun assertFocusedPlayPause() { + assertSingleFocusedNode(FOCUSED_UNLABELED_CLICKABLE, "play/pause button") + } + + private fun assertFocusedSeekBar() { + val interaction = assertSingleFocusedNode(FOCUSED_NON_CLICKABLE, "seek bar") + val rootBounds = composeRule.onRoot().getUnclippedBoundsInRoot() + val focusedBounds = interaction.getUnclippedBoundsInRoot() + val focusedHeight = (focusedBounds.bottom - focusedBounds.top).value + val focusedWidth = (focusedBounds.right - focusedBounds.left).value + val rootHeight = (rootBounds.bottom - rootBounds.top).value + val rootWidth = (rootBounds.right - rootBounds.left).value + assertTrue( + "Expected bounded seek bar focus, root=$rootBounds focused=$focusedBounds", + focusedHeight < rootHeight / 4f && + focusedWidth > rootWidth / 2f, + ) + } + + private fun assertFocusedPlayerSurface() { + awaitAbsent(context.getString(R.string.player_button_audio_subtitles)) + val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot + try { + composeRule.waitUntil(FOCUS_TIMEOUT_MS) { + val focused = focusedNodes() + focused.isNotEmpty() && focused.all { node -> + node.boundsInRoot.width >= rootBounds.width * FULLSCREEN_FOCUS_FRACTION && + node.boundsInRoot.height >= rootBounds.height * FULLSCREEN_FOCUS_FRACTION + } + } + } catch (error: Throwable) { + throw AssertionError( + "Player surface focus did not settle; root=$rootBounds," + + " focused=${focusedSummary(focusedNodes())}", + error, + ) + } + val focused = focusedNodes() + focused.forEach { node -> + assertFalse( + "Focused player branch contains a disabled node: ${focusedSummary(focused)}", + node.config.contains(SemanticsProperties.Disabled), + ) + composeRule.onNode( + SemanticsMatcher("focused player node ${node.id}") { it.id == node.id }, + useUnmergedTree = true, + ).assertIsDisplayed().assertIsFocused() + } + } + + private fun assertFocusedText( + text: String, + substring: Boolean = false, + ) { + assertSingleFocusedNode(focusedTextMatcher(text, substring), "control '$text'") + } + + private fun assertFocusedTextEventually( + text: String, + substring: Boolean = false, + ) { + val matcher = focusedTextMatcher(text, substring) + composeRule.waitUntil(PLAYER_TIMEOUT_MS) { + composeRule.onAllNodes(matcher, useUnmergedTree = true) + .fetchSemanticsNodes() + .size == 1 + } + assertSingleFocusedNode(matcher, "control '$text'") + } + + private fun assertSingleFocusedNode( + matcher: SemanticsMatcher, + description: String, + ) = composeRule.onNode(matcher, useUnmergedTree = true).also { interaction -> + try { + composeRule.waitUntil(FOCUS_TIMEOUT_MS) { + composeRule.onAllNodes(matcher, useUnmergedTree = true) + .fetchSemanticsNodes() + .size == 1 + } + } catch (error: Throwable) { + throw AssertionError( + "$description did not acquire focus; focused=${focusedSummary(focusedNodes())}", + error, + ) + } + val allFocused = composeRule.onAllNodes(isFocused(), useUnmergedTree = true) + .fetchSemanticsNodes() + val expected = composeRule.onAllNodes(matcher, useUnmergedTree = true) + .fetchSemanticsNodes() + .single() + assertEquals( + "Exactly one concrete node must own focus for $description; focused=${focusedSummary(allFocused)}", + 1, + allFocused.size, + ) + assertEquals( + "Focus escaped from $description; focused=${focusedSummary(allFocused)}", + expected.id, + allFocused.single().id, + ) + assertFalse( + "$description is disabled", + expected.config.contains(SemanticsProperties.Disabled), + ) + interaction.assertIsDisplayed().assertIsFocused() + } + + private fun focusedTextMatcher(text: String, substring: Boolean): SemanticsMatcher { + val textMatcher = hasText(text, substring = substring) + return isFocused() and (textMatcher or hasAnyDescendant(textMatcher)) + } + + private fun focusedSummary(nodes: List): String = + nodes.joinToString { node -> + "id=${node.id},text=${node.config.getOrNull(SemanticsProperties.Text)}," + + "bounds=${node.boundsInRoot}" + } + + private fun focusedNodes(): List = + composeRule.onAllNodes(isFocused(), useUnmergedTree = true) + .fetchSemanticsNodes() + + private fun sendPlayerKey(keyCode: Int) { + instrumentation.sendKeyDownUpSync(keyCode) + composeRule.waitForIdle() + } + + private fun pressBack() { + composeRule.activityRule.scenario.onActivity { activity -> + activity.onBackPressedDispatcher.onBackPressed() + } + composeRule.waitForIdle() + } + + private fun awaitText(text: String) { + composeRule.waitUntil(PLAYER_TIMEOUT_MS) { + composeRule.onAllNodesWithText(text, substring = true) + .fetchSemanticsNodes() + .isNotEmpty() + } + composeRule.onNodeWithText(text, substring = true).assertIsDisplayed() + } + + private fun awaitAbsent(text: String) { + composeRule.waitUntil(FOCUS_TIMEOUT_MS) { + composeRule.onAllNodesWithText(text, useUnmergedTree = true) + .fetchSemanticsNodes() + .isEmpty() + } + } + + private fun isTextDisplayed(text: String): Boolean = + composeRule.onAllNodesWithText(text, useUnmergedTree = true) + .fetchSemanticsNodes() + .isNotEmpty() + + private fun awaitJournalPath(path: String) { + try { + composeRule.waitUntil(PLAYER_TIMEOUT_MS) { + server.requestJournal.entries.any { it.path == path } + } + } catch (error: Throwable) { + throw AssertionError( + "Request path $path was not observed; diagnostics=${diagnostics()}", + error, + ) + } + } + + private fun awaitProgressRequest( + description: String, + itemId: Int, + video: Int, + season: Int?, + ): RecordedRequest = awaitRequest(description) { request -> + request.url.encodedPath == "/v1/watching/marktime" && + request.url.queryParameter("id") == itemId.toString() && + request.url.queryParameter("video") == video.toString() && + request.url.queryParameter("season") == season?.toString() && + request.url.queryParameter("time")?.toIntOrNull() != null + } + + private fun assertProgressTimeAtLeast(request: RecordedRequest, expectedSeconds: Int) { + val savedTime = request.url.queryParameter("time")?.toIntOrNull() + assertNotNull("Missing typed progress time in ${request.url}", savedTime) + assertTrue( + "Expected progress >= $expectedSeconds seconds, request=${request.url}", + requireNotNull(savedTime) >= expectedSeconds, + ) + } + + private fun awaitRequest( + description: String, + predicate: (RecordedRequest) -> Boolean, + ): RecordedRequest { + val deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(PLAYER_TIMEOUT_MS) + while (System.nanoTime() < deadline) { + val request = server.takeRequest(timeout = 100, unit = TimeUnit.MILLISECONDS) + if (request != null && predicate(request)) return request + } + fail("Missing $description; journal=${server.requestJournal.entries.takeLast(16)}") + error("unreachable") + } + + private fun routeRequestCount(root: String, leaf: String): Int = + server.requestJournal.matchedRoutes[mediaRouteId(root, leaf)] ?: 0 + + private fun movieRoutes( + itemId: Int, + watchingTime: Int, + media: MovieMediaRoots, + ): List = + apiRoutes( + itemId = itemId, + details = movieDetails(itemId, watchingTime, media), + ) + mediaRoutes(media.high) + mediaRoutes(media.low) + + private fun retryMovieRoutes( + itemId: Int, + media: MovieMediaRoots, + ): List { + val failure = HermeticTestServer.text( + body = "missing", + status = 404, + contentType = HLS_CONTENT_TYPE, + ) + val success = HermeticTestServer.text( + body = fixtureText(FixtureId.HlsMaster), + contentType = HLS_CONTENT_TYPE, + ) + val retrySequence = HermeticTestServer.sequence( + *(List(RETRY_FAILURE_REQUESTS) { failure } + success).toTypedArray(), + ) + return apiRoutes( + itemId = itemId, + details = movieDetails(itemId, watchingTime = 0, media = media), + ) + mediaRoutes(media.high, masterResponse = retrySequence) + mediaRoutes(media.low) + } + + private fun seriesRoutes( + itemId: Int, + media: SeriesMediaRoots, + ): List = + apiRoutes( + itemId = itemId, + details = seriesDetails(itemId, media), + ) + mediaRoutes(media.episodeOne) + mediaRoutes(media.episodeTwo) + + private fun apiRoutes( + itemId: Int, + details: String, + ): List = listOf( + server.route( + id = "details-$itemId", + path = "/v1/items/$itemId", + response = HermeticTestServer.text( + body = details, + contentType = "application/json; charset=utf-8", + ), + required = true, + ), + server.route( + id = "marktime-$itemId", + path = "/v1/watching/marktime", + query = mapOf("id" to itemId.toString()), + queryMode = QueryMatchMode.Contains, + response = HermeticTestServer.text( + body = """{"id":$itemId,"status":0,"time":1}""", + contentType = "application/json; charset=utf-8", + ), + ), + server.route( + id = "toggle-$itemId", + path = "/v1/watching/toggle", + query = mapOf("id" to itemId.toString()), + queryMode = QueryMatchMode.Contains, + response = HermeticTestServer.text( + body = """{"status":1,"watched":1}""", + contentType = "application/json; charset=utf-8", + ), + ), + ) + + private fun mediaRoutes( + root: String, + masterResponse: ResponsePlan = HermeticTestServer.text( + body = fixtureText(FixtureId.HlsMaster), + contentType = HLS_CONTENT_TYPE, + ), + ): List { + val routes = mutableListOf( + server.route( + id = mediaRouteId(root, "master"), + path = "$root/master.m3u8", + queryMode = QueryMatchMode.Contains, + response = masterResponse, + ), + server.route( + id = mediaRouteId(root, "video-360"), + path = "$root/video_360.m3u8", + response = HermeticTestServer.text( + body = fixtureText(FixtureId.HlsVideo360Playlist), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = mediaRouteId(root, "video-720"), + path = "$root/video_720.m3u8", + response = HermeticTestServer.text( + body = fixtureText(FixtureId.HlsVideo720Playlist), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = mediaRouteId(root, "audio-en"), + path = "$root/audio_english.m3u8", + response = HermeticTestServer.text( + body = fixtureText(FixtureId.HlsAudioEnglishPlaylist), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = mediaRouteId(root, "audio-es"), + path = "$root/audio_spanish.m3u8", + response = HermeticTestServer.text( + body = fixtureText(FixtureId.HlsAudioSpanishPlaylist), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = mediaRouteId(root, "subtitle"), + path = "$root/subtitle.vtt", + queryMode = QueryMatchMode.Contains, + response = HermeticTestServer.text( + body = fixtureText(FixtureId.SubtitleWebVtt), + contentType = "text/vtt", + ), + ), + ) + listOf( + "video_360_000.ts", + "video_360_001.ts", + "video_720_000.ts", + "video_720_001.ts", + "audio_english_000.ts", + "audio_english_001.ts", + "audio_english_002.ts", + "audio_spanish_000.ts", + "audio_spanish_001.ts", + "audio_spanish_002.ts", + ).forEach { filename -> + routes += server.route( + id = mediaRouteId(root, filename), + path = "$root/$filename", + response = HermeticTestServer.bytes( + body = PlayerTestFixtures.openPath("hls/$filename", context).use { it.readBytes() }, + contentType = "video/mp2t", + ), + ) + } + return routes + } + + private fun movieDetails( + itemId: Int, + watchingTime: Int, + media: MovieMediaRoots, + ): String = + """ + { + "item": { + "id": $itemId, + "title": "Synthetic movie", + "type": "${ItemType.MOVIE.value}", + "videos": [{ + "id": ${itemId + 1}, + "number": 1, + "duration": 4, + "files": [ + { + "url": {"hls": "${mediaUrl("${media.high}/master.m3u8?scenario=$scenarioToken")}"}, + "quality": "$HIGH_QUALITY_LABEL", + "quality_id": 2, + "w": 1280, + "h": 720 + }, + { + "url": {"hls": "${mediaUrl("${media.low}/master.m3u8?scenario=$scenarioToken")}"}, + "quality": "$LOW_QUALITY_LABEL", + "quality_id": 1, + "w": 640, + "h": 360 + } + ], + "subtitles": [{ + "lang": "$SUBTITLE_LANGUAGE", + "url": "${mediaUrl( + "${media.high}/subtitle.vtt?signature=screen-test&scenario=$scenarioToken", + )}" + }], + "watching": {"time": $watchingTime, "duration": 4, "status": 0} + }] + } + } + """.trimIndent() + + private fun seriesDetails( + itemId: Int, + media: SeriesMediaRoots, + ): String = + """ + { + "item": { + "id": $itemId, + "title": "Synthetic series", + "type": "${ItemType.SERIAL.value}", + "seasons": [{ + "id": ${itemId + 10}, + "number": 1, + "episodes": [ + { + "id": ${itemId + EPISODE_ONE_ID_OFFSET}, + "number": 1, + "title": "First episode", + "duration": 4, + "files": [{ + "url": {"hls": "${mediaUrl("${media.episodeOne}/master.m3u8?scenario=$scenarioToken")}"}, + "quality": "$HIGH_QUALITY_LABEL", + "quality_id": 2 + }], + "watching": {"time": 0, "duration": 4, "status": 0} + }, + { + "id": ${itemId + EPISODE_TWO_ID_OFFSET}, + "number": 2, + "title": "Second episode", + "duration": 4, + "files": [{ + "url": {"hls": "${mediaUrl("${media.episodeTwo}/master.m3u8?scenario=$scenarioToken")}"}, + "quality": "$HIGH_QUALITY_LABEL", + "quality_id": 2 + }], + "watching": {"time": 0, "duration": 4, "status": 0} + } + ] + }] + } + } + """.trimIndent() + + private fun fixtureText(fixture: FixtureId): String = + PlayerTestFixtures.readBytes(fixture, context).toString(Charsets.UTF_8) + + private fun mediaUrl(path: String): String = + server.url(path).replace("http://localhost:", "http://127.0.0.1:") + + private fun mediaRouteId(root: String, leaf: String): String = + "${root.trim('/').replace('/', '-')}:$leaf" + + private fun onMain(block: () -> T): T { + val result = AtomicReference?>(null) + instrumentation.runOnMainSync { + result.set(runCatching(block)) + } + return requireNotNull(result.get()).getOrThrow() + } + + private data class MovieMediaRoots(val itemId: Int) { + val high = "/media/movie-$itemId/high" + val low = "/media/movie-$itemId/low" + } + + private data class SeriesMediaRoots(val itemId: Int) { + val episodeOne = "/media/series-$itemId/episode-1" + val episodeTwo = "/media/series-$itemId/episode-2" + } + + private companion object { + const val HLS_CONTENT_TYPE = "application/vnd.apple.mpegurl" + const val PLAYER_TIMEOUT_MS = 30_000L + const val FOCUS_TIMEOUT_MS = 5_000L + const val POSITION_FENCE_MS = 500L + const val SAVED_POSITION_SECONDS = 2 + const val SAVED_POSITION_FENCE_MS = 1_750L + const val MIN_SAVED_TIME_SECONDS = 1 + const val SEEK_STEP_SECONDS = 10 + const val RETRY_FAILURE_REQUESTS = 6 + const val FULLSCREEN_FOCUS_FRACTION = 0.8f + const val ENGLISH_AUDIO_LABEL = "English" + const val SPANISH_AUDIO_LABEL = "EspaƱol" + const val SPANISH_LANGUAGE = "es" + const val SUBTITLE_LANGUAGE = "en" + const val HIGH_QUALITY_LABEL = "720p" + const val LOW_QUALITY_LABEL = "360p" + const val EPISODE_ONE_ID_OFFSET = 11 + const val EPISODE_TWO_ID_OFFSET = 12 + + val FOCUSED_UNLABELED_CLICKABLE = + SemanticsMatcher("focused clickable control without text") { node -> + node.config.getOrNull(SemanticsProperties.Focused) == true && + node.config.contains(SemanticsActions.OnClick) && + !node.hasTextInSubtree() + } + + val FOCUSED_NON_CLICKABLE = + SemanticsMatcher("focused non-clickable control") { node -> + node.config.getOrNull(SemanticsProperties.Focused) == true && + !node.config.contains(SemanticsActions.OnClick) + } + } +} + +private const val HOST_TEXT = "Player E2E host" + +@Parcelize +private data object PlayerE2EHostScreen : PuberScreen { + @Composable + override fun Content() { + Text(HOST_TEXT) + } +} + +private fun SemanticsNode.hasTextInSubtree(): Boolean { + if (!config.getOrNull(SemanticsProperties.Text).isNullOrEmpty()) return true + return children.any(SemanticsNode::hasTextInSubtree) +} + +private fun View.findPlayerView(): PlayerView? { + if (this is PlayerView) return this + if (this !is ViewGroup) return null + repeat(childCount) { index -> + getChildAt(index).findPlayerView()?.let { return it } + } + return null +} + +private object RecordingAppLauncher : AppLauncher { + val finishCount = AtomicInteger() + + fun reset() { + finishCount.set(0) + } + + override fun restart() = Unit + + override fun finish() { + finishCount.incrementAndGet() + } + + override fun bind(activity: Activity) = Unit + + override fun unbind() = Unit +} diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt new file mode 100644 index 00000000..bddde4fd --- /dev/null +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt @@ -0,0 +1,444 @@ +package com.kino.puber.ui.feature.player.vm + +import android.os.Handler +import android.os.Looper +import android.view.ViewGroup +import androidx.activity.ComponentActivity +import androidx.media3.common.PlaybackException +import androidx.media3.common.Player +import androidx.media3.common.util.UnstableApi +import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor +import androidx.media3.datasource.cache.SimpleCache +import androidx.media3.database.StandaloneDatabaseProvider +import androidx.media3.ui.PlayerView +import androidx.test.core.app.ActivityScenario +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import com.kino.puber.data.repository.PlayerPreferencesRepository +import com.kino.puber.playertestfixtures.FixtureId +import com.kino.puber.playertestfixtures.PlayerTestFixtures +import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal +import com.kino.puber.playertestfixtures.server.HermeticRoute +import com.kino.puber.playertestfixtures.server.HermeticTestServer +import com.kino.puber.playertestfixtures.server.ResponseOutcome +import com.kino.puber.playertestfixtures.server.ResponsePlan +import com.kino.puber.profile.PlayerTestControl +import com.kino.puber.ui.feature.player.model.BufferPreset +import java.io.File +import java.util.UUID +import java.util.concurrent.CopyOnWriteArrayList +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicReference +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertThrows +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +@OptIn(UnstableApi::class) +@RunWith(AndroidJUnit4::class) +internal class PlaybackControllerDeviceTest { + + private val context + get() = InstrumentationRegistry.getInstrumentation().targetContext + + private lateinit var server: PlayerTestControl + private lateinit var cacheDirectory: File + private lateinit var cache: SimpleCache + private lateinit var controller: PlaybackController + private lateinit var scenario: ActivityScenario + private lateinit var playerView: PlayerView + + @Before + fun setUp() { + LoopbackNetworkJournal(context).clear() + server = PlayerTestControl() + server.start(mediaRoutes()) + + cacheDirectory = context.cacheDir.resolve("player-device-${UUID.randomUUID()}") + cache = SimpleCache( + cacheDirectory, + LeastRecentlyUsedCacheEvictor(MAX_CACHE_BYTES), + StandaloneDatabaseProvider(context), + ) + controller = PlaybackController( + context = context, + okHttpClient = okhttp3.OkHttpClient(), + mediaCache = cache, + playerPreferencesRepository = PlayerPreferencesRepository(context), + ) + scenario = ActivityScenario.launch(ComponentActivity::class.java) + scenario.onActivity { activity -> + playerView = PlayerView(activity).apply { + useController = false + layoutParams = ViewGroup.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.MATCH_PARENT, + ) + } + activity.setContentView(playerView) + } + } + + @After + fun tearDown() { + var cleanupFailure: Throwable? = null + if (::scenario.isInitialized) { + scenario.onActivity { + playerView.player = null + controller.release() + } + scenario.close() + } + if (::cache.isInitialized) { + cache.release() + } + if (::server.isInitialized) { + try { + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + try { + server.assertRequiredRoutesRequested() + } catch (error: IllegalStateException) { + cleanupFailure = error + } + try { + server.assertNoUnknownRequests(MAX_DIAGNOSTIC_REQUESTS) + } catch (error: AssertionError) { + cleanupFailure?.addSuppressed(error) ?: run { + cleanupFailure = error + } + } + } catch (error: Throwable) { + cleanupFailure = error + } finally { + server.close() + } + } + val networkJournal = LoopbackNetworkJournal(context) + check(networkJournal.snapshot().isEmpty()) { + "Unexpected network egress: ${networkJournal.snapshot()}" + } + if (::cacheDirectory.isInitialized) { + check(!cacheDirectory.exists() || cacheDirectory.deleteRecursively()) { + "Failed to clean player cache: $cacheDirectory" + } + } + cleanupFailure?.let { throw it } + } + + @Test + fun progressiveMp4_reachesReadyRendersFrameAdvancesAndEnds() { + val probe = prepare(FixtureId.ProgressiveMp4, startPositionMs = 0L) + + await(probe.ready, "progressive READY") + await(probe.firstFrame, "progressive first rendered frame") + awaitCondition("progressive position advance") { + controller.currentPosition > 0L + } + await(probe.ended, "progressive ENDED") + + assertNoPlaybackError(probe) + assertTrue( + "Expected a progressive MP4 request; journal=${server.requestJournal.entries}", + server.requestJournal.entries.any { + it.path == "/media/progressive.mp4" && + it.outcome is ResponseOutcome.Completed + }, + ) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + @Test + fun hlsVod_reachesReadyRendersFrameAdvancesAndEnds() { + val probe = prepare(FixtureId.HlsMaster, startPositionMs = 0L) + + await(probe.ready, "HLS READY") + await(probe.firstFrame, "HLS first rendered frame") + awaitCondition("HLS position advance") { + controller.currentPosition > 0L + } + await(probe.ended, "HLS ENDED") + + assertNoPlaybackError(probe) + val requests = server.requestJournal.entries + assertTrue( + "Expected HLS master and media playlist requests, journal=$requests", + requests.any { it.path == "/media/hls/master.m3u8" } && + requests.any { it.path == "/media/hls/video_360.m3u8" }, + ) + assertTrue( + "Expected HLS segment request, journal=$requests", + requests.any { it.path.startsWith("/media/hls/video_") && it.path.endsWith(".ts") }, + ) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + @Test + fun progressivePlayback_controlsAndStartPositionUseRealPlayerEvents() { + val probe = prepare(FixtureId.ProgressiveMp4, startPositionMs = 1_000L) + + await(probe.ready, "progressive READY") + await(probe.firstFrame, "progressive first rendered frame") + awaitCondition("non-zero start position") { + controller.currentPosition >= 900L + } + + runOnPlayer { controller.pause() } + awaitCondition("pause") { !controller.isPlaying } + + runOnPlayer { + controller.setSpeed(2f) + controller.seekTo(2_000L) + } + awaitCondition("forward seek") { + controller.currentPosition in 1_800L..2_400L + } + + runOnPlayer { controller.play() } + awaitCondition("play after seek") { controller.isPlaying } + + runOnPlayer { controller.seekTo(250L) } + awaitCondition("backward seek") { + controller.currentPosition in 0L..700L + } + + runOnPlayer { controller.seekTo(3_700L) } + await(probe.ended, "near-end seek ENDED") + assertNoPlaybackError(probe) + + runOnPlayer { controller.play() } + awaitCondition("replay after ended") { + controller.currentPosition < 1_000L && controller.isPlaying + } + assertEquals(2f, playerRead { checkNotNull(player).getPlaybackParameters().speed }, 0f) + } + + @Test + fun awaitCondition_failsClosedWhenConditionRemainsFalse() { + val error = assertThrows(AssertionError::class.java) { + awaitCondition( + label = "deliberately false condition", + timeoutMs = FAIL_CLOSED_TIMEOUT_MS, + ) { + false + } + } + + assertTrue(error.message.orEmpty().contains("deliberately false condition")) + } + + @Test + fun unexpectedLoopbackRequest_failsClosedWithBoundedDiagnostics() { + server.reset(emptyList()) + okhttp3.OkHttpClient().newCall( + okhttp3.Request.Builder() + .url(loopbackUrl("/unexpected-player-request")) + .build(), + ).execute().close() + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + + val error = assertThrows(AssertionError::class.java) { + server.assertNoUnknownRequests(MAX_DIAGNOSTIC_REQUESTS) + } + + assertTrue(error.message.orEmpty().contains("/unexpected-player-request")) + server.reset(emptyList()) + } + + private fun prepare( + fixture: FixtureId, + startPositionMs: Long? = null, + ): PlayerProbe { + val probe = PlayerProbe() + val streamUrl = when (fixture) { + FixtureId.ProgressiveMp4 -> loopbackUrl("/media/progressive.mp4") + FixtureId.HlsMaster -> loopbackUrl("/media/hls/master.m3u8") + else -> error("Unsupported device fixture: $fixture") + } + scenario.onActivity { + controller.prepare( + streamUrl = streamUrl, + subtitles = null, + startPosition = startPositionMs, + bufferPreset = BufferPreset.SMALL, + fastDns = false, + ) + val player = checkNotNull(controller.player) + player.addListener(probe) + playerView.player = player + } + return probe + } + + private fun loopbackUrl(path: String): String = + server.url(path).replace("http://localhost:", "http://127.0.0.1:") + + private fun mediaRoutes(): List { + val routes = mutableListOf( + server.route( + id = "progressive", + path = "/media/progressive.mp4", + response = ResponsePlan.Range( + body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), + contentType = "video/mp4", + ), + ), + server.route( + id = "master", + path = "/media/hls/master.m3u8", + response = HermeticTestServer.text( + body = PlayerTestFixtures.readBytes(FixtureId.HlsMaster, context) + .toString(Charsets.UTF_8), + contentType = HLS_CONTENT_TYPE, + ), + ), + ) + FixtureId.entries + .filter { it.path.startsWith("hls/") && it != FixtureId.HlsMaster } + .forEach { fixture -> + routes += server.route( + id = fixture.path, + path = "/media/${fixture.path}", + response = HermeticTestServer.text( + body = PlayerTestFixtures.readBytes(fixture, context) + .toString(Charsets.UTF_8), + contentType = HLS_CONTENT_TYPE, + ), + ) + } + listOf( + "video_360_000.ts", + "video_360_001.ts", + "video_720_000.ts", + "video_720_001.ts", + "audio_english_000.ts", + "audio_english_001.ts", + "audio_english_002.ts", + "audio_spanish_000.ts", + "audio_spanish_001.ts", + "audio_spanish_002.ts", + ).forEach { filename -> + routes += server.route( + id = filename, + path = "/media/hls/$filename", + response = HermeticTestServer.bytes( + body = PlayerTestFixtures.openPath("hls/$filename", context) + .use { it.readBytes() }, + contentType = "video/mp2t", + ), + ) + } + return routes + } + + private fun runOnPlayer(block: () -> Unit) { + scenario.onActivity { block() } + } + + private fun await(latch: CountDownLatch, label: String) { + assertTrue( + "$label timed out; diagnostics=${diagnostics()}", + latch.await(PLAYER_TIMEOUT_SECONDS, TimeUnit.SECONDS), + ) + } + + private fun awaitCondition( + label: String, + timeoutMs: Long = TimeUnit.SECONDS.toMillis(PLAYER_TIMEOUT_SECONDS), + condition: () -> Boolean, + ) { + val reached = CountDownLatch(1) + val conditionSatisfied = AtomicBoolean(false) + val handler = Handler(Looper.getMainLooper()) + val deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(timeoutMs) + lateinit var check: Runnable + check = Runnable { + if (condition()) { + conditionSatisfied.set(true) + reached.countDown() + } else if (System.nanoTime() < deadline) { + handler.postDelayed(check, CONDITION_POLL_MS) + } else { + reached.countDown() + } + } + handler.post(check) + val pollingCompleted = reached.await( + timeoutMs + CONDITION_TIMEOUT_GRACE_MS, + TimeUnit.MILLISECONDS, + ) + handler.removeCallbacks(check) + assertTrue( + "$label polling timed out; diagnostics=${diagnostics()}", + pollingCompleted, + ) + assertTrue( + "$label condition remained false; diagnostics=${diagnostics()}", + conditionSatisfied.get(), + ) + } + + private fun assertNoPlaybackError(probe: PlayerProbe) { + assertTrue( + "Playback error=${probe.error.get()?.errorCodeName}; diagnostics=${diagnostics()}", + probe.error.get() == null, + ) + } + + private fun diagnostics(): String { + val playerState = playerRead { + val player = controller.player + val debug = controller.getDebugInfo() + "state=${player?.playbackState},isPlaying=${player?.isPlaying}," + + "position=${player?.currentPosition},duration=${player?.duration}," + + "formats=${debug?.videoResolution}/${debug?.videoCodec}/" + + "${debug?.audioCodec}" + } + return "$playerState,requests=${server.requestJournal.entries.takeLast(12)}" + } + + private fun playerRead(read: PlaybackController.() -> T): T { + val value = AtomicReference() + scenario.onActivity { value.set(read(controller)) } + return checkNotNull(value.get()) + } + + private class PlayerProbe : Player.Listener { + val ready = CountDownLatch(1) + val firstFrame = CountDownLatch(1) + val ended = CountDownLatch(1) + val error = AtomicReference() + val stateEvents = CopyOnWriteArrayList() + + override fun onPlaybackStateChanged(playbackState: Int) { + stateEvents += playbackState + when (playbackState) { + Player.STATE_READY -> ready.countDown() + Player.STATE_ENDED -> ended.countDown() + } + } + + override fun onRenderedFirstFrame() { + firstFrame.countDown() + } + + override fun onPlayerError(error: PlaybackException) { + this.error.set(error) + ended.countDown() + } + } + + private companion object { + const val HLS_CONTENT_TYPE = "application/vnd.apple.mpegurl" + const val MAX_CACHE_BYTES = 32L * 1024L * 1024L + const val PLAYER_TIMEOUT_SECONDS = 20L + const val CONDITION_POLL_MS = 25L + const val CONDITION_TIMEOUT_GRACE_MS = 1_000L + const val FAIL_CLOSED_TIMEOUT_MS = 100L + const val MAX_DIAGNOSTIC_REQUESTS = 8 + } +} diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt new file mode 100644 index 00000000..25f48d76 --- /dev/null +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt @@ -0,0 +1,860 @@ +package com.kino.puber.ui.feature.player.vm + +import android.os.Handler +import android.os.Looper +import android.view.ViewGroup +import androidx.activity.ComponentActivity +import androidx.media3.common.C +import androidx.media3.common.PlaybackException +import androidx.media3.common.Player +import androidx.media3.common.Tracks +import androidx.media3.common.text.Cue +import androidx.media3.common.util.UnstableApi +import androidx.media3.common.text.CueGroup +import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor +import androidx.media3.datasource.cache.SimpleCache +import androidx.media3.database.StandaloneDatabaseProvider +import androidx.media3.ui.PlayerView +import androidx.test.core.app.ActivityScenario +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import com.kino.puber.data.api.models.SubtitleLink +import com.kino.puber.data.repository.PlayerPreferencesRepository +import com.kino.puber.playertestfixtures.FixtureId +import com.kino.puber.playertestfixtures.PlayerTestFixtures +import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal +import com.kino.puber.playertestfixtures.server.HermeticRoute +import com.kino.puber.playertestfixtures.server.HermeticTestServer +import com.kino.puber.playertestfixtures.server.QueryMatchMode +import com.kino.puber.playertestfixtures.server.ResponseOutcome +import com.kino.puber.playertestfixtures.server.ResponsePlan +import com.kino.puber.profile.PlayerTestControl +import com.kino.puber.ui.feature.player.model.AudioTrackUIState +import com.kino.puber.ui.feature.player.model.BufferPreset +import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState +import java.io.File +import java.util.UUID +import java.util.concurrent.CopyOnWriteArrayList +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicReference +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +@OptIn(UnstableApi::class) +@RunWith(AndroidJUnit4::class) +internal class PlaybackControllerNetworkTracksTest { + + private val context + get() = InstrumentationRegistry.getInstrumentation().targetContext + + private lateinit var server: PlayerTestControl + private lateinit var cacheDirectory: File + private lateinit var cache: SimpleCache + private lateinit var controller: PlaybackController + private lateinit var scenario: ActivityScenario + private lateinit var playerView: PlayerView + + @Before + fun setUp() { + LoopbackNetworkJournal(context).clear() + server = PlayerTestControl() + server.start() + + cacheDirectory = context.cacheDir.resolve("player-network-${UUID.randomUUID()}") + cache = SimpleCache( + cacheDirectory, + LeastRecentlyUsedCacheEvictor(MAX_CACHE_BYTES), + StandaloneDatabaseProvider(context), + ) + controller = PlaybackController( + context = context, + okHttpClient = okhttp3.OkHttpClient(), + mediaCache = cache, + playerPreferencesRepository = PlayerPreferencesRepository(context), + ) + scenario = ActivityScenario.launch(ComponentActivity::class.java) + scenario.onActivity { activity -> + playerView = PlayerView(activity).apply { + useController = false + layoutParams = ViewGroup.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.MATCH_PARENT, + ) + } + activity.setContentView(playerView) + } + } + + @After + fun tearDown() { + if (::scenario.isInitialized) { + scenario.onActivity { + playerView.player = null + controller.release() + } + scenario.close() + } + if (::cache.isInitialized) cache.release() + if (::server.isInitialized) { + try { + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + server.assertNoUnknownRequests(MAX_DIAGNOSTIC_REQUESTS) + } finally { + server.close() + } + } + check(LoopbackNetworkJournal(context).snapshot().isEmpty()) { + "Unexpected network egress: ${LoopbackNetworkJournal(context).snapshot()}" + } + if (::cacheDirectory.isInitialized) { + check(!cacheDirectory.exists() || cacheDirectory.deleteRecursively()) { + "Failed to clean player cache: $cacheDirectory" + } + } + } + + @Test + fun hlsTracks_selectsAudioAndSubtitle_observesCueAndDisablesText() { + server.reset(commonHlsRoutes()) + val subtitleUrl = loopbackUrl("/media/subtitle.vtt?signature=test-signature") + val probe = prepare( + path = "/media/hls/master.m3u8", + subtitles = listOf( + SubtitleLink( + lang = "en", + url = subtitleUrl, + ), + ), + ) + + awaitReady(probe) + runOnPlayer { controller.pause() } + awaitCondition("both AAC renditions are exposed") { + audioTracks().map(AudioTrackUIState::language).toSet() == setOf("en", "es") + } + assertEquals(setOf("en", "es"), audioTracks().map(AudioTrackUIState::language).toSet()) + + runOnPlayer { controller.selectAudioTrack(1) } + awaitCondition("Spanish AAC rendition selected") { + selectedAudioLanguage() == "es" + } + + val subtitle = SubtitleTrackUIState( + index = 1, + label = "English", + language = "en", + url = subtitleUrl, + ) + runOnPlayer { controller.selectSubtitle(subtitle) } + awaitCondition("side-loaded WebVTT track enabled on HLS") { + !textTracksDisabled() && selectedTextTrack() + } + assertEquals("es", selectedAudioLanguage()) + runOnPlayer { + controller.seekTo(900L) + controller.play() + } + awaitCondition("fixture cue is rendered") { + probe.cueTexts.any { it.contains("Synthetic player fixture cue") } || + currentCueTexts().any { it.contains("Synthetic player fixture cue") } + } + assertTrue(server.requestJournal.entries.any { it.path == "/media/subtitle.vtt" }) + + runOnPlayer { controller.selectSubtitle(null) } + awaitCondition("WebVTT track disabled") { textTracksDisabled() } + assertEquals("es", selectedAudioLanguage()) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + @Test + fun hlsPreparation_exposesCodecTracksBeforeTheFirstMediaChunkCompletes() { + val gate = CountDownLatch(1) + server.reset( + commonHlsRoutes( + extraRoutes = listOf( + server.route( + id = "chunkless-video-gate", + path = "/media/hls/video_720_000.ts", + response = HermeticTestServer.delayed( + gate = gate, + body = fixtureBytes("hls/video_720_000.ts"), + contentType = "video/mp2t", + ), + ), + server.route( + id = "chunkless-audio-gate", + path = "/media/hls/audio_english_000.ts", + response = HermeticTestServer.delayed( + gate = gate, + body = fixtureBytes("hls/audio_english_000.ts"), + contentType = "video/mp2t", + ), + ), + ), + ), + ) + val probe = prepare("/media/hls/master.m3u8") + + try { + awaitCondition("first HLS media chunks are blocked") { + server.activeRequestCount > 0 + } + awaitCondition("chunkless HLS preparation exposes CODECS tracks") { + server.activeRequestCount > 0 && playerRead { + val trackTypes = player?.currentTracks?.groups + ?.map { it.type } + .orEmpty() + C.TRACK_TYPE_VIDEO in trackTypes && C.TRACK_TYPE_AUDIO in trackTypes + } + } + } finally { + gate.countDown() + } + + awaitReady(probe) + assertTrue(probe.error.get() == null) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + @Test + fun hlsSwitch_preservesPositionIntentTracks_andLastStreamWins() { + server.reset(commonHlsRoutes()) + val lowUrl = loopbackUrl("/media/hls/quality-low.m3u8") + val highUrl = loopbackUrl("/media/hls/quality-high.m3u8") + val subtitleUrl = loopbackUrl("/media/subtitle.vtt?scenario=quality-switch") + val subtitle = SubtitleLink( + lang = "en", + url = subtitleUrl, + ) + val subtitleTrack = SubtitleTrackUIState(1, "English", "en", subtitleUrl) + val probe = prepare("/media/hls/quality-low.m3u8", listOf(subtitle)) + + awaitReady(probe) + awaitCondition("audio tracks before switch") { audioTracks().size == 2 } + runOnPlayer { + controller.selectAudioTrack(1) + controller.selectSubtitle(subtitleTrack) + controller.seekTo(1_500L) + } + awaitCondition("position before switch") { + currentPosition() in 1_000L..2_100L + } + awaitCondition("Spanish selection before switch") { selectedAudioLanguage() == "es" } + awaitCondition("WebVTT selection before switch") { + !textTracksDisabled() && selectedTextTrack() + } + awaitCondition("WebVTT request before switch") { + server.requestJournal.entries.any { it.path == "/media/subtitle.vtt" } + } + runOnPlayer { controller.pause() } + awaitCondition("paused switch source") { !isPlaying() } + val pausedPosition = currentPosition() + + runOnPlayer { controller.switchStream(highUrl, listOf(subtitle)) } + awaitCondition("high quality source prepared") { + currentMediaPath() == "/media/hls/quality-high.m3u8" && + playbackState() == Player.STATE_READY + } + assertFalse(textTracksDisabled()) + assertTrue(selectedTextTrack()) + assertFalse(isPlaying()) + assertEquals(PlaybackIntent.Paused, playbackIntent()) + assertTrue(currentPosition() in (pausedPosition - 800L)..(pausedPosition + 800L)) + awaitCondition("audio selection restored after switch") { selectedAudioLanguage() == "es" } + runOnPlayer { controller.play() } + awaitCondition("play intent restored") { + isPlaying() && playbackIntent() == PlaybackIntent.PlayRequested + } + runOnPlayer { + controller.switchStream(lowUrl, listOf(subtitle)) + controller.switchStream(highUrl, listOf(subtitle)) + controller.switchStream(lowUrl, listOf(subtitle)) + } + awaitCondition("last rapid switch wins") { + currentMediaPath() == "/media/hls/quality-low.m3u8" && + playbackIntent() == PlaybackIntent.PlayRequested + } + assertTrue(currentPosition() >= pausedPosition - 1_000L) + val masterPaths = server.requestJournal.entries + .filter { it.path.startsWith("/media/hls/quality-") } + .map { it.path } + assertTrue(masterPaths.contains("/media/hls/quality-low.m3u8")) + assertTrue(masterPaths.contains("/media/hls/quality-high.m3u8")) + assertEquals(0, server.requestJournal.unknownRequests.size) + assertTrue(probe.error.get() == null) + } + + @Test + fun progressiveSwitch_restoresSelectedSubtitleAndPausedIntent() { + server.reset(commonHlsRoutes()) + val subtitleUrl = loopbackUrl("/media/subtitle.vtt") + val subtitle = SubtitleTrackUIState(1, "English", "en", subtitleUrl) + val first = prepare( + path = "/media/progressive-a.mp4", + subtitles = listOf(SubtitleLink(lang = "en", url = subtitleUrl)), + ) + + awaitReady(first) + runOnPlayer { controller.pause() } + runOnPlayer { controller.selectSubtitle(subtitle) } + awaitCondition("subtitle selected before progressive switch") { + !textTracksDisabled() && selectedTextTrack() + } + val positionBeforeSwitch = currentPosition() + + val secondUrl = loopbackUrl("/media/progressive-b.mp4") + runOnPlayer { + controller.switchStream( + streamUrl = secondUrl, + subtitles = listOf(SubtitleLink(lang = "en", url = subtitleUrl)), + ) + } + awaitCondition("progressive switch completes") { + currentMediaPath() == "/media/progressive-b.mp4" && + playbackState() == Player.STATE_READY + } + assertEquals(PlaybackIntent.Paused, playbackIntent()) + assertFalse(isPlaying()) + assertTrue(currentPosition() in (positionBeforeSwitch - 800L)..(positionBeforeSwitch + 800L)) + awaitCondition("subtitle selection restored after progressive switch") { + !textTracksDisabled() && selectedTextTrack() + } + runOnPlayer { controller.selectSubtitle(null) } + awaitCondition("subtitle disabled after progressive switch") { textTracksDisabled() } + } + + @Test + fun hls404AndMalformedPlaylist_failWithoutUnboundedRetry() { + runPlaylistFailure( + path = "/media/fault-404.m3u8", + response = HermeticTestServer.text( + body = "not found", + status = 404, + contentType = HLS_CONTENT_TYPE, + ), + ) + runPlaylistFailure( + path = "/media/fault-malformed.m3u8", + response = HermeticTestServer.text( + body = "this is not an HLS playlist", + contentType = HLS_CONTENT_TYPE, + ), + ) + } + + @Test + fun hlsVariant400_fallsBackToTheHealthyVariant() { + assertVariantHttpFailureFallsBack(status = 400) + } + + @Test + fun hlsVariant502_fallsBackToTheHealthyVariant() { + assertVariantHttpFailureFallsBack(status = 502) + } + + private fun assertVariantHttpFailureFallsBack(status: Int) { + val validLowPlaylist = playlist(FixtureId.HlsVideo360Playlist) + server.reset( + commonHlsRoutes( + lowPlaylist = HermeticTestServer.sequence( + HermeticTestServer.text( + body = "variant unavailable", + status = status, + contentType = HLS_CONTENT_TYPE, + ), + HermeticTestServer.text( + body = validLowPlaylist, + contentType = HLS_CONTENT_TYPE, + ), + ), + ), + ) + val probe = prepare("/media/hls/master.m3u8") + + awaitReady(probe) + awaitCondition("healthy HLS variant after $status") { + playbackState() == Player.STATE_READY && + server.requestJournal.entries.any { it.path == "/media/hls/video_720.m3u8" } + } + val failedVariant = server.requestJournal.entries.filter { + it.path == "/media/hls/video_360.m3u8" + } + assertEquals(1, failedVariant.size) + assertEquals( + status, + (failedVariant.single().outcome as ResponseOutcome.Completed).status, + ) + assertTrue(server.requestJournal.entries.any { it.path == "/media/hls/video_720.m3u8" }) + assertTrue(probe.error.get() == null) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + @Test + fun hlsDelayedAndInterruptedSegment_enterBufferingThenRecover() { + val gate = CountDownLatch(1) + server.reset( + commonHlsRoutes( + qualityLowMasterBody = singleVariantMaster("video_360.m3u8"), + video360Playlist = HermeticTestServer.text( + body = playlist(FixtureId.HlsVideo360Playlist), + contentType = HLS_CONTENT_TYPE, + ), + extraRoutes = listOf( + server.route( + id = "delayed-segment", + path = "/media/hls/video_360_000.ts", + response = HermeticTestServer.delayed( + gate = gate, + body = fixtureBytes("hls/video_360_000.ts"), + contentType = "video/mp2t", + ), + ), + ), + ), + ) + val delayedProbe = prepare("/media/hls/quality-low.m3u8") + awaitCondition("delayed segment enters BUFFERING") { + delayedProbe.stateEvents.contains(Player.STATE_BUFFERING) || + playbackState() == Player.STATE_BUFFERING + } + gate.countDown() + awaitReady(delayedProbe) + assertTrue(delayedProbe.error.get() == null) + + releasePlayerAndReset() + val segment = fixtureBytes("hls/video_360_000.ts") + server.reset( + commonHlsRoutes( + qualityLowMasterBody = singleVariantMaster("video_360_recovery.m3u8"), + extraRoutes = listOf( + server.route( + id = "recovery-master", + path = "/media/hls/recovery.m3u8", + response = HermeticTestServer.text( + body = singleVariantMaster("video_360_recovery.m3u8"), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = "recovering-playlist", + path = "/media/hls/video_360_recovery.m3u8", + response = HermeticTestServer.text( + body = playlist(FixtureId.HlsVideo360Playlist) + .replace("video_360_", "video_360_recovery_"), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = "recovering-segment", + path = "/media/hls/video_360_recovery_000.ts", + response = HermeticTestServer.sequence( + HermeticTestServer.truncated( + body = segment, + bytesToWrite = segment.size / 4, + contentType = "video/mp2t", + ), + HermeticTestServer.bytes(segment, contentType = "video/mp2t"), + ), + ), + server.route( + id = "recovering-segment-1", + path = "/media/hls/video_360_recovery_001.ts", + response = HermeticTestServer.bytes( + fixtureBytes("hls/video_360_001.ts"), + contentType = "video/mp2t", + ), + ), + ), + ), + ) + val recoveryProbe = prepare("/media/hls/recovery.m3u8") + awaitReady(recoveryProbe) + val recoveryEntries = server.requestJournal.entries.filter { + it.routeId == "recovering-segment" + } + assertTrue( + "Expected interrupted segment recovery; entries=$recoveryEntries", + recoveryEntries.size >= 2, + ) + assertEquals(200, (recoveryEntries[0].outcome as ResponseOutcome.Completed).status) + assertEquals(200, (recoveryEntries[1].outcome as ResponseOutcome.Completed).status) + assertTrue( + "Expected a ranged recovery request; entries=$recoveryEntries", + recoveryEntries[1].range != null, + ) + assertTrue(recoveryProbe.error.get() == null) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + @Test + fun playerMediaNetworkIsolation_rejectsExternalRedirectAndSanitizesViolation() { + server.reset( + listOf( + server.route( + id = "external-redirect", + path = "/media/redirect.m3u8", + response = HermeticTestServer.redirect( + "https://redirect-user:redirect-password@example.com/blocked" + + "?token=must-not-be-recorded", + ), + ), + ), + ) + val probe = prepare("/media/redirect.m3u8") + + awaitCondition("external redirect fails locally") { probe.error.get() != null } + awaitCondition("one external violation is journaled") { + LoopbackNetworkJournal(context).snapshot().size == 1 + } + try { + val violations = LoopbackNetworkJournal(context).snapshot() + assertEquals(1, violations.size) + assertTrue(violations.single().startsWith("https://example.com:443")) + assertFalse(violations.single().contains("redirect-user")) + assertFalse(violations.single().contains("redirect-password")) + assertFalse(violations.single().contains("token")) + assertFalse(violations.single().contains("?")) + assertEquals(0, server.requestJournal.unknownRequests.size) + } finally { + LoopbackNetworkJournal(context).clear() + } + } + + private fun runPlaylistFailure(path: String, response: ResponsePlan) { + releasePlayerAndReset() + server.reset( + listOf( + server.route(id = "fault", path = path, response = response), + ), + ) + val probe = prepare(path) + awaitCondition("playlist failure $path") { probe.error.get() != null } + val requests = server.requestJournal.entries.filter { it.path == path } + assertTrue( + "Expected bounded retry count for $path, got ${requests.size}", + requests.size in 1..6, + ) + assertTrue(probe.error.get() is PlaybackException) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + private fun prepare( + path: String, + subtitles: List? = null, + ): PlayerProbe { + val probe = PlayerProbe() + val streamUrl = loopbackUrl(path) + scenario.onActivity { + controller.prepare( + streamUrl = streamUrl, + subtitles = subtitles, + startPosition = 0L, + bufferPreset = BufferPreset.SMALL, + fastDns = false, + ) + val player = checkNotNull(controller.player) + player.addListener(probe) + playerView.player = player + } + return probe + } + + private fun releasePlayerAndReset() { + scenario.onActivity { + playerView.player = null + controller.release() + } + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + } + + private fun awaitReady(probe: PlayerProbe) { + awaitCondition("READY") { + playbackState() == Player.STATE_READY + } + assertTrue(probe.error.get() == null) + } + + private fun currentPosition(): Long = playerRead { currentPosition } + + private fun isPlaying(): Boolean = playerRead { isPlaying } + + private fun playbackIntent(): PlaybackIntent = playerRead { playbackIntent } + + private fun playbackState(): Int = playerRead { player?.playbackState ?: Player.STATE_IDLE } + + private fun audioTracks(): List { + val value = AtomicReference>() + scenario.onActivity { + value.set( + controller.player?.currentTracks?.groups + ?.filter { it.type == C.TRACK_TYPE_AUDIO } + ?.mapIndexed { index, group -> + val format = group.getTrackFormat(0) + AudioTrackUIState( + index = index, + label = format.label.orEmpty(), + language = format.language.orEmpty(), + ) + } + .orEmpty(), + ) + } + return value.get().orEmpty() + } + + private fun selectedAudioLanguage(): String? = playerRead { + player?.currentTracks?.groups + ?.filter { it.type == C.TRACK_TYPE_AUDIO } + ?.firstOrNull { it.isSelected } + ?.getTrackFormat(0) + ?.language + } + + private fun selectedTextTrack(): Boolean = playerRead { + player?.currentTracks?.groups + ?.filter { it.type == C.TRACK_TYPE_TEXT } + ?.any { it.isSelected } == true + } + + private fun textTracksDisabled(): Boolean = playerRead { + player?.trackSelectionParameters?.disabledTrackTypes?.contains(C.TRACK_TYPE_TEXT) == true + } + + private fun currentMediaPath(): String? = playerRead { + player?.currentMediaItem?.localConfiguration?.uri?.encodedPath + } + + private fun currentCueTexts(): List = playerRead { + player?.currentCues?.cues?.mapNotNull { it.text?.toString() }.orEmpty() + } + + private fun playerRead(read: PlaybackController.() -> T): T { + val value = AtomicReference() + scenario.onActivity { value.set(read(controller)) } + return value.get() + } + + private fun runOnPlayer(block: () -> Unit) { + scenario.onActivity { block() } + } + + private fun awaitCondition(label: String, condition: () -> Boolean) { + val reached = CountDownLatch(1) + val result = AtomicBoolean(false) + val handler = Handler(Looper.getMainLooper()) + val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(PLAYER_TIMEOUT_SECONDS) + lateinit var check: Runnable + check = Runnable { + if (condition()) { + result.set(true) + reached.countDown() + } else if (System.nanoTime() < deadline) { + handler.postDelayed(check, CONDITION_POLL_MS) + } else { + reached.countDown() + } + } + handler.post(check) + assertTrue("$label timed out; diagnostics=${diagnostics()}", reached.await( + PLAYER_TIMEOUT_SECONDS + 1, + TimeUnit.SECONDS, + )) + handler.removeCallbacks(check) + assertTrue("$label was not reached; diagnostics=${diagnostics()}", result.get()) + } + + private fun diagnostics(): String { + val playerState = playerRead { + val player = controller.player + val debug = controller.getDebugInfo() + "state=${player?.playbackState},isPlaying=${player?.isPlaying}," + + "position=${player?.currentPosition},duration=${player?.duration}," + + "formats=${debug?.videoResolution}/${debug?.videoCodec}/${debug?.audioCodec}" + } + return "$playerState,requests=${server.requestJournal.entries.takeLast(12)}" + } + + private fun loopbackUrl(path: String): String = + server.url(path).replace("http://localhost:", "http://127.0.0.1:") + + private fun commonHlsRoutes( + masterBody: String = fixtureText(FixtureId.HlsMaster), + qualityLowMasterBody: String = singleVariantMaster("video_360.m3u8"), + lowPlaylist: ResponsePlan = HermeticTestServer.text( + body = playlist(FixtureId.HlsVideo360Playlist), + contentType = HLS_CONTENT_TYPE, + ), + highPlaylist: ResponsePlan = HermeticTestServer.text( + body = playlist(FixtureId.HlsVideo720Playlist), + contentType = HLS_CONTENT_TYPE, + ), + video360Playlist: ResponsePlan? = null, + extraRoutes: List = emptyList(), + ): List { + val routes = mutableListOf( + server.route( + id = "progressive", + path = "/media/progressive.mp4", + response = ResponsePlan.Range( + body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), + contentType = "video/mp4", + ), + ), + server.route( + id = "progressive-a", + path = "/media/progressive-a.mp4", + response = ResponsePlan.Range( + body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), + contentType = "video/mp4", + ), + ), + server.route( + id = "progressive-b", + path = "/media/progressive-b.mp4", + response = ResponsePlan.Range( + body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), + contentType = "video/mp4", + ), + ), + server.route( + id = "master", + path = "/media/hls/master.m3u8", + response = HermeticTestServer.text( + body = masterBody, + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = "quality-low", + path = "/media/hls/quality-low.m3u8", + response = HermeticTestServer.text( + body = qualityLowMasterBody, + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = "quality-high", + path = "/media/hls/quality-high.m3u8", + response = HermeticTestServer.text( + body = singleVariantMaster("video_720.m3u8"), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = "video-360-playlist", + path = "/media/hls/video_360.m3u8", + response = video360Playlist ?: lowPlaylist, + ), + server.route( + id = "video-720-playlist", + path = "/media/hls/video_720.m3u8", + response = highPlaylist, + ), + server.route( + id = "audio-english-playlist", + path = "/media/hls/audio_english.m3u8", + response = HermeticTestServer.text( + body = playlist(FixtureId.HlsAudioEnglishPlaylist), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = "audio-spanish-playlist", + path = "/media/hls/audio_spanish.m3u8", + response = HermeticTestServer.text( + body = playlist(FixtureId.HlsAudioSpanishPlaylist), + contentType = HLS_CONTENT_TYPE, + ), + ), + server.route( + id = "subtitle", + path = "/media/subtitle.vtt", + queryMode = QueryMatchMode.Contains, + response = HermeticTestServer.text( + body = fixtureText(FixtureId.SubtitleWebVtt), + contentType = "text/vtt", + ), + ), + ) + listOf( + "video_360_000.ts", + "video_360_001.ts", + "video_720_000.ts", + "video_720_001.ts", + "audio_english_000.ts", + "audio_english_001.ts", + "audio_english_002.ts", + "audio_spanish_000.ts", + "audio_spanish_001.ts", + "audio_spanish_002.ts", + ).forEach { filename -> + routes += server.route( + id = filename, + path = "/media/hls/$filename", + response = HermeticTestServer.bytes( + body = PlayerTestFixtures.openPath("hls/$filename", context).use { it.readBytes() }, + contentType = "video/mp2t", + ), + ) + } + return extraRoutes + routes + } + + private fun fixtureText(fixture: FixtureId): String = + PlayerTestFixtures.readBytes(fixture, context).toString(Charsets.UTF_8) + + private fun playlist(fixture: FixtureId): String = fixtureText(fixture) + + private fun fixtureBytes(path: String): ByteArray = + PlayerTestFixtures.openPath(path, context).use { it.readBytes() } + + private fun singleVariantMaster(videoPlaylist: String): String = + """ + #EXTM3U + #EXT-X-VERSION:3 + #EXT-X-INDEPENDENT-SEGMENTS + #EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="English",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,URI="audio_english.m3u8" + #EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="EspaƱol",LANGUAGE="es",DEFAULT=NO,AUTOSELECT=YES,URI="audio_spanish.m3u8" + #EXT-X-STREAM-INF:BANDWIDTH=800000,RESOLUTION=640x360,CODECS="avc1.42c01e,mp4a.40.2",AUDIO="audio" + $videoPlaylist + """.trimIndent() + + private class PlayerProbe : Player.Listener { + val stateEvents = CopyOnWriteArrayList() + val cueTexts = CopyOnWriteArrayList() + val error = AtomicReference() + + override fun onPlaybackStateChanged(playbackState: Int) { + stateEvents += playbackState + } + + override fun onTracksChanged(tracks: Tracks) = Unit + + override fun onCues(cueGroup: CueGroup) { + cueTexts += cueGroup.cues.mapNotNull { it.text?.toString() } + } + + override fun onCues(cues: List) { + cueTexts += cues.mapNotNull { it.text?.toString() } + } + + override fun onPlayerError(error: PlaybackException) { + this.error.set(error) + } + } + + private companion object { + const val HLS_CONTENT_TYPE = "application/vnd.apple.mpegurl" + const val MAX_CACHE_BYTES = 32L * 1024L * 1024L + const val PLAYER_TIMEOUT_SECONDS = 20L + const val CONDITION_POLL_MS = 25L + const val MAX_DIAGNOSTIC_REQUESTS = 8 + } +} diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt new file mode 100644 index 00000000..04ab479a --- /dev/null +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt @@ -0,0 +1,752 @@ +package com.kino.puber.ui.feature.player.vm + +import android.media.MediaCodecList +import android.view.ViewGroup +import androidx.activity.ComponentActivity +import androidx.lifecycle.Lifecycle +import androidx.media3.common.C +import androidx.media3.common.MimeTypes +import androidx.media3.common.PlaybackException +import androidx.media3.common.Player +import androidx.media3.common.util.UnstableApi +import androidx.media3.exoplayer.analytics.AnalyticsListener +import androidx.media3.exoplayer.source.LoadEventInfo +import androidx.media3.exoplayer.source.MediaLoadData +import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor +import androidx.media3.datasource.cache.SimpleCache +import androidx.media3.database.StandaloneDatabaseProvider +import androidx.media3.ui.PlayerView +import androidx.test.core.app.ActivityScenario +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import com.kino.puber.data.repository.PlayerPreferencesRepository +import com.kino.puber.playertestfixtures.FixtureId +import com.kino.puber.playertestfixtures.PlayerTestFixtures +import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal +import com.kino.puber.playertestfixtures.server.HermeticRoute +import com.kino.puber.playertestfixtures.server.HermeticTestServer +import com.kino.puber.playertestfixtures.server.ResponsePlan +import com.kino.puber.profile.PlayerTestControl +import com.kino.puber.ui.feature.player.model.AudioTrackUIState +import com.kino.puber.ui.feature.player.model.BufferPreset +import java.io.File +import java.io.IOException +import java.util.UUID +import java.util.concurrent.CopyOnWriteArrayList +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicInteger +import java.util.concurrent.atomic.AtomicReference +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +@OptIn(UnstableApi::class) +@RunWith(AndroidJUnit4::class) +internal class PlaybackControllerResourcesTest { + + private val context + get() = InstrumentationRegistry.getInstrumentation().targetContext + + private lateinit var server: PlayerTestControl + private lateinit var cacheDirectory: File + private lateinit var cache: SimpleCache + private lateinit var controller: PlaybackController + private lateinit var scenario: ActivityScenario + private lateinit var playerView: PlayerView + private var responseGate: CountDownLatch? = null + + @Before + fun setUp() { + LoopbackNetworkJournal(context).clear() + server = PlayerTestControl() + server.start() + + cacheDirectory = context.cacheDir.resolve("player-resources-${UUID.randomUUID()}") + cache = SimpleCache( + cacheDirectory, + LeastRecentlyUsedCacheEvictor(MAX_CACHE_BYTES), + StandaloneDatabaseProvider(context), + ) + controller = PlaybackController( + context = context, + okHttpClient = okhttp3.OkHttpClient(), + mediaCache = cache, + playerPreferencesRepository = PlayerPreferencesRepository(context), + ) + scenario = ActivityScenario.launch(ComponentActivity::class.java) + attachPlayerView() + } + + @After + fun tearDown() { + responseGate?.countDown() + if (::scenario.isInitialized) { + scenario.onActivity { + playerView.player = null + controller.release() + } + scenario.close() + } + if (::cache.isInitialized) { + cache.release() + } + if (::server.isInitialized) { + try { + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + server.assertNoUnknownRequests(MAX_DIAGNOSTIC_REQUESTS) + } finally { + server.close() + } + } + assertTrue( + "Owned cache directory was not cleaned: $cacheDirectory", + !cacheDirectory.exists() || cacheDirectory.deleteRecursively(), + ) + assertTrue( + "Unexpected network egress: ${LoopbackNetworkJournal(context).snapshot()}", + LoopbackNetworkJournal(context).snapshot().isEmpty(), + ) + } + + @Test + fun progressiveReplay_readsCommittedCacheAfterUpstreamRouteIsRemoved() { + server.reset(progressiveRoutes()) + val url = loopbackUrl("/media/progressive.mp4") + val first = prepare(url) + + awaitReady(first) + await(first.ended, "initial playback ended", first) + val cachedBytes = cache.getCachedBytes(url, 0L, C.LENGTH_UNSET.toLong()) + assertTrue("Expected committed media bytes, got $cachedBytes", cachedBytes > 0L) + releaseController(first) + + server.reset(emptyList()) + val replay = prepare(url) + awaitReady(replay) + runOnActivity { + controller.pause() + controller.seekTo(CACHED_REPLAY_SEEK_POSITION_MS) + } + awaitCondition("cached replay seek crosses the position fence", replay) { + playbackState() == Player.STATE_READY && + !isPlaying() && + currentPosition() in CACHED_REPLAY_SEEK_POSITION_MS.. + CACHED_REPLAY_SEEK_FENCE_END_MS + } + assertTrue( + "Cached replay seek should not request a removed upstream route: " + + server.requestJournal.entries, + server.requestJournal.entries.isEmpty(), + ) + assertNull("Cached replay seek reported a playback error", replay.error.get()) + releaseController(replay) + assertResourcesQuiescent("cached replay seek", replay) + } + + @Test + fun emptyCache_loadsNormally_andCorruptOwnedEntryRecoversWithoutPoisoningNextScenario() { + val url = loopbackUrl("/media/progressive.mp4") + server.reset(progressiveRoutes()) + val miss = prepare(url) + + awaitReady(miss) + assertTrue( + "Empty cache should use loopback upstream", + server.requestJournal.entries.any { it.path == "/media/progressive.mp4" }, + ) + releaseController(miss) + + cache.removeResource(url) + writeCorruptCacheEntry(url) + server.reset(progressiveRoutes()) + val corrupt = prepare(url) + awaitReadyOrError(corrupt) + assertTrue( + "Corrupt cache must produce a controlled recovery or error: ${diagnostics(corrupt)}", + corrupt.ready.count == 0L || corrupt.error.get() != null, + ) + releaseController(corrupt) + + cache.removeResource(url) + assertTrue(cache.getCachedSpans(url).isEmpty()) + server.reset(progressiveRoutes()) + val clean = prepare(url) + awaitReady(clean) + assertNull(clean.error.get()) + assertTrue( + "Clean scenario should load after corrupt entry cleanup", + server.requestJournal.entries.any { it.path == "/media/progressive.mp4" }, + ) + releaseController(clean) + assertResourcesQuiescent("clean post-corruption scenario", clean) + } + + @Test + fun lifecycle_detachReattach_backgroundForegroundAndRecreation_keepPlayerUsable() { + server.reset(progressiveRoutes()) + val url = loopbackUrl("/media/progressive.mp4") + val probe = prepare(url) + + awaitReady(probe) + runOnActivity { playerView.player = null } + assertNull(playerRead { playerView.player }) + runOnActivity { playerView.player = controller.player } + assertNotNull(playerRead { playerView.player }) + awaitCondition("reattached player remains ready", probe) { + playbackState() == Player.STATE_READY + } + + scenario.moveToState(Lifecycle.State.CREATED) + scenario.moveToState(Lifecycle.State.RESUMED) + attachPlayerView() + assertNotNull(playerRead { playerView.player }) + awaitCondition("foreground player remains ready", probe) { + playbackState() == Player.STATE_READY + } + + scenario.recreate() + attachPlayerView() + assertNotNull(playerRead { playerView.player }) + awaitCondition("recreated activity receives the player", probe) { + playbackState() == Player.STATE_READY + } + assertTrue("Player diagnostics were unexpectedly empty", diagnostics(probe).isNotBlank()) + + releaseController(probe) + assertResourcesQuiescent("activity recreation", probe) + } + + @Test + fun progressiveDecode_reportsMandatoryCapabilitiesDecodersCountersAndAnalytics() { + val capabilities = CodecCapabilityReport.capture() + assertTrue( + "H.264 decoder is mandatory; ${capabilities.boundedSummary()}", + capabilities.h264Decoders.isNotEmpty(), + ) + assertTrue( + "AAC decoder is mandatory; ${capabilities.boundedSummary()}", + capabilities.aacDecoders.isNotEmpty(), + ) + + server.reset(progressiveRoutes()) + val probe = prepare(loopbackUrl("/media/progressive.mp4")) + awaitReady(probe) + await(probe.firstFrame, "first frame", probe) + awaitCondition("H.264/AAC decoder diagnostics", probe) { + val snapshot = decoderSnapshot() + snapshot.videoMimeType == MimeTypes.VIDEO_H264 && + snapshot.audioMimeType == MimeTypes.AUDIO_AAC && + snapshot.videoDecoderInitCount > 0 && + snapshot.audioDecoderInitCount > 0 && + snapshot.videoQueuedInputBuffers > 0 && + snapshot.audioQueuedInputBuffers > 0 && + snapshot.renderedVideoBuffers > 0 && + probe.analytics.videoDecoderName.get() != null && + probe.analytics.audioDecoderName.get() != null + } + + val snapshot = decoderSnapshot() + assertEquals(MimeTypes.VIDEO_H264, snapshot.videoMimeType) + assertEquals(MimeTypes.AUDIO_AAC, snapshot.audioMimeType) + assertTrue("Video decoder counters were empty: $snapshot", snapshot.videoQueuedInputBuffers > 0) + assertTrue("Audio decoder counters were empty: $snapshot", snapshot.audioQueuedInputBuffers > 0) + assertTrue("No video frame was rendered: $snapshot", snapshot.renderedVideoBuffers > 0) + assertTrue("Unexpected analytics load errors: ${probe.analytics.boundedEvents()}", probe.analytics.loadErrors.isEmpty()) + assertTrue("Unexpected analytics player errors: ${probe.analytics.boundedEvents()}", probe.analytics.playerErrors.isEmpty()) + + releaseController(probe) + assertResourcesQuiescent("mandatory codec diagnostics", probe) + } + + @Test + fun releaseDuringBlockedLoad_closesRequestsAndDetachesReleasedView() { + val gate = CountDownLatch(1) + responseGate = gate + val url = loopbackUrl("/media/blocked.mp4") + server.reset( + listOf( + server.route( + id = "blocked", + path = "/media/blocked.mp4", + response = HermeticTestServer.delayed( + gate = gate, + body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), + contentType = "video/mp4", + ), + ), + ), + ) + val probe = prepare(url) + awaitCondition("blocked request starts", probe) { + server.activeRequestCount > 0 + } + + releaseController(probe, awaitRequests = false) + gate.countDown() + assertResourcesQuiescent("release during blocked load", probe) + assertTrue("Stale callback reported an error: ${probe.error.get()}", probe.error.get() == null) + } + + @Test + fun boundedPreparePlaySeekReleaseLoop_leavesNoActiveRequestsOrOpenSpans() { + val url = loopbackUrl("/media/progressive.mp4") + repeat(STRESS_ITERATIONS) { iteration -> + server.reset(progressiveRoutes()) + val probe = prepare(url) + awaitReady(probe) + runOnActivity { + controller.pause() + controller.seekTo(350L) + controller.play() + } + awaitCondition("stress iteration $iteration advances", probe) { + currentPosition() >= 300L + } + assertNull(probe.error.get()) + releaseController(probe) + assertResourcesQuiescent("stress iteration $iteration", probe) + } + } + + private fun attachPlayerView() { + scenario.onActivity { activity -> + playerView = PlayerView(activity).apply { + useController = false + layoutParams = ViewGroup.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.MATCH_PARENT, + ) + player = controller.player + } + activity.setContentView(playerView) + } + } + + private fun prepare(url: String): PlayerProbe { + val probe = PlayerProbe() + scenario.onActivity { + controller.prepare( + streamUrl = url, + subtitles = null, + startPosition = 0L, + bufferPreset = BufferPreset.SMALL, + fastDns = false, + ) + val player = checkNotNull(controller.player) + player.addListener(probe) + player.addAnalyticsListener(probe.analytics) + controller.setCallback(probe.callback) + playerView.player = player + } + return probe + } + + private fun releaseController( + probe: PlayerProbe, + awaitRequests: Boolean = true, + ) { + runOnActivity { + playerView.player = null + controller.release() + probe.callback.markReleased() + } + assertNull(playerRead { controller.player }) + assertNull(playerRead { playerView.player }) + assertFalse(playerRead { playerView.keepScreenOn }) + if (awaitRequests) { + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + drainPlayerThread() + probe.callback.assertNoCallbacksAfterRelease() + } + } + + private fun writeCorruptCacheEntry(url: String) { + val corruptBytes = "not-a-media-container".toByteArray() + val hole = cache.startReadWrite(url, 0L, corruptBytes.size.toLong()) + try { + val file = cache.startFile(url, 0L, corruptBytes.size.toLong()) + file.outputStream().use { it.write(corruptBytes) } + cache.commitFile(file, corruptBytes.size.toLong()) + } finally { + cache.releaseHoleSpan(hole) + } + assertTrue(cache.getCachedBytes(url, 0L, corruptBytes.size.toLong()) > 0L) + } + + private fun progressiveRoutes(): List = + listOf( + server.route( + id = "progressive", + path = "/media/progressive.mp4", + response = ResponsePlan.Range( + body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), + contentType = "video/mp4", + ), + ), + ) + + private fun awaitReady(probe: PlayerProbe) { + await(probe.ready, "READY", probe) + assertNull("Unexpected playback error: ${diagnostics(probe)}", probe.error.get()) + } + + private fun awaitReadyOrError(probe: PlayerProbe) { + await(probe.outcome, "corrupt-cache outcome", probe) + } + + private fun await( + latch: CountDownLatch, + label: String, + probe: PlayerProbe, + ) { + assertTrue( + "$label timed out; ${diagnostics(probe)}", + latch.await(PLAYER_TIMEOUT_SECONDS, TimeUnit.SECONDS), + ) + } + + private fun awaitCondition( + label: String, + probe: PlayerProbe, + condition: () -> Boolean, + ) { + val reached = CountDownLatch(1) + val handler = android.os.Handler(android.os.Looper.getMainLooper()) + val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(PLAYER_TIMEOUT_SECONDS) + lateinit var check: Runnable + check = Runnable { + if (condition()) { + reached.countDown() + } else if (System.nanoTime() < deadline) { + handler.postDelayed(check, CONDITION_POLL_MS) + } else { + reached.countDown() + } + } + handler.post(check) + assertTrue( + "$label timed out; ${diagnostics(probe)}", + reached.await(PLAYER_TIMEOUT_SECONDS + 1L, TimeUnit.SECONDS), + ) + handler.removeCallbacks(check) + assertTrue("$label was not reached; ${diagnostics(probe)}", condition()) + } + + private fun assertResourcesQuiescent( + label: String, + probe: PlayerProbe, + ) { + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + drainPlayerThread() + probe.callback.assertNoCallbacksAfterRelease() + assertEquals("$label left active requests", 0, server.activeRequestCount) + assertCacheOwnershipReleased(label) + drainPlayerThread() + probe.callback.assertNoCallbacksAfterRelease() + assertNull("$label retained a controller player", playerRead { controller.player }) + assertNull("$label retained a PlayerView player", playerRead { playerView.player }) + assertFalse("$label retained keep-screen-on ownership", playerRead { playerView.keepScreenOn }) + assertEquals( + "$label recorded unexpected egress", + emptyList(), + LoopbackNetworkJournal(context).snapshot(), + ) + } + + private fun assertCacheOwnershipReleased(label: String) { + cache.getKeys().toList().forEach { key -> + val lockProbe = awaitCacheWriteLockRelease(key) + assertNotNull("$label retained a cache write lock for $key", lockProbe) + checkNotNull(lockProbe).let { span -> + assertTrue("$label returned a non-hole lock probe for $key: $span", span.isHoleSpan) + cache.releaseHoleSpan(span) + } + cache.removeResource(key) + assertTrue("$label recreated cache spans for $key", cache.getCachedSpans(key).isEmpty()) + } + } + + private fun awaitCacheWriteLockRelease(key: String): androidx.media3.datasource.cache.CacheSpan? { + val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(CACHE_CLEANUP_TIMEOUT_SECONDS) + do { + cache.removeResource(key) + if (cache.getCachedSpans(key).isEmpty()) { + cache.startReadWriteNonBlocking(key, 0L, C.LENGTH_UNSET.toLong())?.let { return it } + } + } while ( + System.nanoTime() < deadline && + CountDownLatch(1).await(CACHE_CLEANUP_POLL_MS, TimeUnit.MILLISECONDS).not() + ) + return null + } + + private fun drainPlayerThread() { + runOnActivity { /* ActivityScenario is a synchronous main-thread fence. */ } + } + + private fun diagnostics(probe: PlayerProbe): String { + val value = AtomicReference() + scenario.onActivity { + val player = controller.player + val debug = controller.getDebugInfo() + val requestTail = server.requestJournal.entries.takeLast(MAX_DIAGNOSTIC_REQUESTS) + .map { "${it.method} ${it.path} ${it.range.orEmpty()} ${it.outcome}" } + val decoder = decoderSnapshot(player) + value.set( + "state=${player?.playbackState},isPlaying=${player?.isPlaying}," + + "position=${player?.currentPosition},formats=" + + "${debug?.videoResolution}/${debug?.videoCodec}/${debug?.audioCodec}," + + "decoders=${probe.analytics.decoderSummary()}," + + "decoderCounters=$decoder," + + "buffered=${debug?.bufferedDuration},error=${probe.error.get()}," + + "analytics=${probe.analytics.boundedEvents()}," + + "capabilities=${CodecCapabilityReport.capture().boundedSummary()}," + + "requests=$requestTail", + ) + } + return checkNotNull(value.get()) + } + + private fun decoderSnapshot(): DecoderSnapshot = playerRead { + decoderSnapshot(controller.player) + } + + private fun decoderSnapshot(player: androidx.media3.exoplayer.ExoPlayer?): DecoderSnapshot { + val videoCounters = player?.videoDecoderCounters?.apply { ensureUpdated() } + val audioCounters = player?.audioDecoderCounters?.apply { ensureUpdated() } + return DecoderSnapshot( + videoMimeType = player?.videoFormat?.sampleMimeType, + audioMimeType = player?.audioFormat?.sampleMimeType, + videoDecoderInitCount = videoCounters?.decoderInitCount ?: 0, + audioDecoderInitCount = audioCounters?.decoderInitCount ?: 0, + videoQueuedInputBuffers = videoCounters?.queuedInputBufferCount ?: 0, + audioQueuedInputBuffers = audioCounters?.queuedInputBufferCount ?: 0, + renderedVideoBuffers = videoCounters?.renderedOutputBufferCount ?: 0, + droppedVideoBuffers = videoCounters?.droppedBufferCount ?: 0, + ) + } + + private fun loopbackUrl(path: String): String = + server.url(path).replace("http://localhost:", "http://127.0.0.1:") + + private fun runOnActivity(block: () -> Unit) { + scenario.onActivity { block() } + } + + private fun playerRead(read: () -> T): T { + val value = AtomicReference() + scenario.onActivity { value.set(read()) } + @Suppress("UNCHECKED_CAST") + return value.get() as T + } + + private fun currentPosition(): Long = playerRead { controller.currentPosition } + + private fun isPlaying(): Boolean = playerRead { controller.player?.isPlaying == true } + + private fun playbackState(): Int = + playerRead { controller.player?.playbackState ?: Player.STATE_IDLE } + + private class PlayerProbe : Player.Listener { + val ready = CountDownLatch(1) + val firstFrame = CountDownLatch(1) + val ended = CountDownLatch(1) + val outcome = CountDownLatch(1) + val error = AtomicReference() + val stateEvents = CopyOnWriteArrayList() + val callback = CallbackProbe() + val analytics = AnalyticsProbe() + + override fun onPlaybackStateChanged(playbackState: Int) { + stateEvents += playbackState + when (playbackState) { + Player.STATE_READY -> { + ready.countDown() + outcome.countDown() + } + Player.STATE_ENDED -> ended.countDown() + } + } + + override fun onRenderedFirstFrame() { + firstFrame.countDown() + } + + override fun onPlayerError(error: PlaybackException) { + this.error.set(error) + outcome.countDown() + } + } + + private class CallbackProbe : PlaybackControl.Callback { + private val released = AtomicBoolean(false) + private val eventCount = AtomicInteger() + private val countAtRelease = AtomicInteger(-1) + private val staleEvents = CopyOnWriteArrayList() + + override fun onPlaybackStateChanged(snapshot: PlaybackSnapshot) { + record("state:${snapshot.intent}:${snapshot.isBuffering}:${snapshot.isPlaying}") + } + + override fun onPlaybackEnded() { + record("ended") + } + + override fun onTracksUpdated(audioTracks: List, selectedIndex: Int) { + record("tracks:${audioTracks.size}:$selectedIndex") + } + + override fun onError(message: String) { + record("error") + } + + fun markReleased() { + countAtRelease.set(eventCount.get()) + released.set(true) + } + + fun assertNoCallbacksAfterRelease() { + assertEquals("Callbacks advanced after release: $staleEvents", countAtRelease.get(), eventCount.get()) + assertTrue("Stale callbacks after release: $staleEvents", staleEvents.isEmpty()) + } + + private fun record(event: String) { + eventCount.incrementAndGet() + if (released.get()) { + staleEvents += event + } + } + } + + private class AnalyticsProbe : AnalyticsListener { + val videoDecoderName = AtomicReference() + val audioDecoderName = AtomicReference() + val loadErrors = CopyOnWriteArrayList() + val playerErrors = CopyOnWriteArrayList() + private val events = CopyOnWriteArrayList() + + override fun onPlaybackStateChanged(eventTime: AnalyticsListener.EventTime, state: Int) { + addEvent("state:$state") + } + + override fun onVideoDecoderInitialized( + eventTime: AnalyticsListener.EventTime, + decoderName: String, + initializedTimestampMs: Long, + initializationDurationMs: Long, + ) { + videoDecoderName.set(decoderName) + addEvent("video-decoder:${decoderName.take(MAX_DECODER_NAME_LENGTH)}") + } + + override fun onAudioDecoderInitialized( + eventTime: AnalyticsListener.EventTime, + decoderName: String, + initializedTimestampMs: Long, + initializationDurationMs: Long, + ) { + audioDecoderName.set(decoderName) + addEvent("audio-decoder:${decoderName.take(MAX_DECODER_NAME_LENGTH)}") + } + + override fun onDroppedVideoFrames( + eventTime: AnalyticsListener.EventTime, + droppedFrames: Int, + elapsedMs: Long, + ) { + addEvent("dropped:$droppedFrames") + } + + override fun onLoadError( + eventTime: AnalyticsListener.EventTime, + loadEventInfo: LoadEventInfo, + mediaLoadData: MediaLoadData, + error: IOException, + wasCanceled: Boolean, + ) { + val value = "${error.javaClass.simpleName}:canceled=$wasCanceled" + loadErrors += value + addEvent("load-error:$value") + } + + override fun onPlayerError( + eventTime: AnalyticsListener.EventTime, + error: PlaybackException, + ) { + playerErrors += error.errorCodeName + addEvent("player-error:${error.errorCodeName}") + } + + fun decoderSummary(): String = + "video=${videoDecoderName.get()?.take(MAX_DECODER_NAME_LENGTH)}," + + "audio=${audioDecoderName.get()?.take(MAX_DECODER_NAME_LENGTH)}" + + fun boundedEvents(): List = events.takeLast(MAX_ANALYTICS_EVENTS) + + private fun addEvent(event: String) { + events += event + while (events.size > MAX_ANALYTICS_EVENTS) { + events.removeAt(0) + } + } + } + + private data class DecoderSnapshot( + val videoMimeType: String?, + val audioMimeType: String?, + val videoDecoderInitCount: Int, + val audioDecoderInitCount: Int, + val videoQueuedInputBuffers: Int, + val audioQueuedInputBuffers: Int, + val renderedVideoBuffers: Int, + val droppedVideoBuffers: Int, + ) + + private data class CodecCapabilityReport( + val h264Decoders: List, + val aacDecoders: List, + ) { + fun boundedSummary(): String = + "H264=${h264Decoders.take(MAX_CAPABILITY_DECODERS)}," + + "AAC=${aacDecoders.take(MAX_CAPABILITY_DECODERS)}" + + companion object { + fun capture(): CodecCapabilityReport { + val decoders = MediaCodecList(MediaCodecList.ALL_CODECS).codecInfos + .filterNot { it.isEncoder } + return CodecCapabilityReport( + h264Decoders = decoders.supporting(MimeTypes.VIDEO_H264), + aacDecoders = decoders.supporting(MimeTypes.AUDIO_AAC), + ) + } + + private fun List.supporting(mimeType: String): List = + filter { codec -> + codec.supportedTypes.any { it.equals(mimeType, ignoreCase = true) } + }.map { it.name }.sorted() + } + } + + private companion object { + const val MAX_CACHE_BYTES = 32L * 1024L * 1024L + const val PLAYER_TIMEOUT_SECONDS = 20L + const val CONDITION_POLL_MS = 25L + const val CACHE_CLEANUP_TIMEOUT_SECONDS = 10L + const val CACHE_CLEANUP_POLL_MS = 25L + const val MAX_DIAGNOSTIC_REQUESTS = 8 + const val MAX_ANALYTICS_EVENTS = 12 + const val MAX_CAPABILITY_DECODERS = 4 + const val MAX_DECODER_NAME_LENGTH = 80 + const val STRESS_ITERATIONS = 3 + const val CACHED_REPLAY_SEEK_POSITION_MS = 2_000L + const val CACHED_REPLAY_SEEK_FENCE_END_MS = 2_500L + } +} diff --git a/app/src/instrumentation/java/com/kino/puber/profile/BaselineNetworkBlocker.kt b/app/src/instrumentation/java/com/kino/puber/profile/BaselineNetworkBlocker.kt index 754804b4..00418667 100644 --- a/app/src/instrumentation/java/com/kino/puber/profile/BaselineNetworkBlocker.kt +++ b/app/src/instrumentation/java/com/kino/puber/profile/BaselineNetworkBlocker.kt @@ -1,151 +1,15 @@ package com.kino.puber.profile import android.content.Context -import java.io.File -import java.io.RandomAccessFile -import java.net.InetSocketAddress -import java.net.Proxy -import java.net.ProxySelector -import java.net.SocketAddress -import java.net.URI -import java.nio.charset.StandardCharsets +import com.kino.puber.playertestfixtures.network.LoopbackNetworkBlocker +import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal internal object BaselineNetworkBlocker { - @Synchronized fun install(context: Context, allowedOrigin: String) { - val normalizedOrigin = allowedOrigin.removeSuffix("/").lowercase() - val current = installedSelector - if (current?.allowedOrigin == normalizedOrigin) return - - val journal = BaselineNetworkJournal(context.applicationContext) - val selector = BlockingProxySelector(normalizedOrigin, journal) - ProxySelector.setDefault(selector) - installedSelector = selector - } - - private var installedSelector: BlockingProxySelector? = null - - private class BlockingProxySelector( - val allowedOrigin: String, - private val journal: BaselineNetworkJournal, - ) : ProxySelector() { - - override fun select(uri: URI): List { - requireNotNull(uri) { "URI must not be null" } - return if (origin(uri) == allowedOrigin) { - listOf(Proxy.NO_PROXY) - } else { - journal.record(uri) - listOf(DENY_PROXY) - } - } - - override fun connectFailed(uri: URI, sa: SocketAddress?, ioe: java.io.IOException) { - if (origin(uri) != allowedOrigin) { - journal.record(uri) - } - } - - private fun origin(uri: URI): String { - val scheme = uri.scheme.orEmpty().lowercase() - val host = uri.host.orEmpty().lowercase() - val port = uri.port.takeIf { it >= 0 } ?: defaultPort(scheme) - return "$scheme://$host:$port" - } - - private fun defaultPort(scheme: String): Int = when (scheme) { - "http" -> HTTP_PORT - "https" -> HTTPS_PORT - else -> -1 - } + LoopbackNetworkBlocker.install(context, allowedOrigin) } - private const val HTTP_PORT = 80 - private const val HTTPS_PORT = 443 - private const val DENY_PROXY_PORT = 9 - private val DENY_PROXY = Proxy( - Proxy.Type.HTTP, - InetSocketAddress.createUnresolved("127.0.0.1", DENY_PROXY_PORT), - ) -} - -internal class BaselineNetworkJournal(context: Context) { - private val directory = File(context.noBackupFilesDir, DIRECTORY) - private val journalFile = File(directory, JOURNAL_FILE) - private val lockFile = File(directory, LOCK_FILE) - - init { - check(directory.isDirectory || directory.mkdirs()) { - "Failed to create baseline network journal directory" - } - } - - fun record(uri: URI) = withFileLock { - val violation = normalizedViolation(uri) - val current = readEntries() - if (violation !in current) { - writeEntries((current + violation).takeLast(MAX_ENTRIES)) - } - } - - fun snapshot(): List = withFileLock(::readEntries) - - fun clear() = withFileLock { - writeEntries(emptyList()) - } - - private fun readEntries(): List { - if (!journalFile.isFile) return emptyList() - return journalFile.readLines(StandardCharsets.UTF_8) - .filter(String::isNotBlank) - .takeLast(MAX_ENTRIES) - } - - private fun writeEntries(entries: List) { - val payload = entries.joinToString(ENTRY_SEPARATOR) - .toByteArray(StandardCharsets.UTF_8) - RandomAccessFile(journalFile, "rw").use { file -> - file.setLength(0) - file.write(payload) - file.fd.sync() - } - } - - private fun normalizedViolation(uri: URI): String { - val scheme = uri.scheme.orEmpty().lowercase() - val host = uri.host.orEmpty().lowercase() - val port = uri.port.takeIf { it >= 0 } ?: when (scheme) { - "http" -> HTTP_PORT - "https" -> HTTPS_PORT - else -> -1 - } - val path = uri.rawPath.orEmpty() - .ifBlank { "/" } - .replace('\n', '_') - .replace('\r', '_') - return "$scheme://$host:$port$path".take(MAX_ENTRY_LENGTH) - } - - private inline fun withFileLock(block: () -> T): T = - synchronized(PROCESS_LOCK) { - RandomAccessFile(lockFile, "rw").use { lockAccess -> - lockAccess.channel.lock().use { - block() - } - } - } - - private companion object { - const val HTTP_PORT = 80 - const val HTTPS_PORT = 443 - const val DIRECTORY = "baseline_network_journal" - const val JOURNAL_FILE = "violations" - const val LOCK_FILE = "journal.lock" - const val ENTRY_SEPARATOR = "\n" - const val MAX_ENTRIES = 64 - const val MAX_ENTRY_LENGTH = 512 - - val PROCESS_LOCK = Any() - } + fun journal(context: Context): LoopbackNetworkJournal = + LoopbackNetworkJournal(context.applicationContext) } diff --git a/app/src/instrumentation/java/com/kino/puber/profile/BaselineProfileControlReceiver.kt b/app/src/instrumentation/java/com/kino/puber/profile/BaselineProfileControlReceiver.kt index 763623ee..65acbc63 100644 --- a/app/src/instrumentation/java/com/kino/puber/profile/BaselineProfileControlReceiver.kt +++ b/app/src/instrumentation/java/com/kino/puber/profile/BaselineProfileControlReceiver.kt @@ -8,7 +8,7 @@ import android.content.Intent internal class BaselineProfileControlReceiver : BroadcastReceiver() { override fun onReceive(context: Context, intent: Intent) { - val journal = BaselineNetworkJournal(context) + val journal = BaselineNetworkBlocker.journal(context) when (intent.action) { ACTION_CLEAR -> { journal.clear() diff --git a/app/src/instrumentation/java/com/kino/puber/profile/PlayerTestControl.kt b/app/src/instrumentation/java/com/kino/puber/profile/PlayerTestControl.kt new file mode 100644 index 00000000..f3e38042 --- /dev/null +++ b/app/src/instrumentation/java/com/kino/puber/profile/PlayerTestControl.kt @@ -0,0 +1,100 @@ +package com.kino.puber.profile + +import com.kino.puber.BuildConfig +import com.kino.puber.playertestfixtures.server.HermeticRequestJournal +import com.kino.puber.playertestfixtures.server.HermeticRoute +import com.kino.puber.playertestfixtures.server.HermeticTestServer +import com.kino.puber.playertestfixtures.server.QueryMatchMode +import com.kino.puber.playertestfixtures.server.ResponsePlan +import java.io.Closeable +import java.util.concurrent.TimeUnit +import mockwebserver3.RecordedRequest + +/** + * Instrumentation-owned lifecycle boundary for the common hermetic player + * server. Android tests may define routes and inspect bounded evidence, but + * they do not create or own the underlying server. + */ +internal class PlayerTestControl( + port: Int = BuildConfig.BASELINE_MOCK_PORT, +) : Closeable { + + private val server = HermeticTestServer(port = port) + + val requestJournal: HermeticRequestJournal.Snapshot + get() = server.requestJournal + + val activeRequestCount: Int + get() = server.activeRequestCount + + fun start(initialRoutes: List = emptyList()) { + server.start() + server.reset(initialRoutes) + } + + fun reset(routes: List) { + server.reset(routes) + } + + fun route( + id: String, + method: String = "GET", + path: String, + query: Map = emptyMap(), + queryMode: QueryMatchMode = QueryMatchMode.Exact, + response: ResponsePlan, + required: Boolean = false, + minimumRequests: Int = 1, + ): HermeticRoute = server.route( + id = id, + method = method, + path = path, + query = query, + queryMode = queryMode, + response = response, + required = required, + minimumRequests = minimumRequests, + ) + + fun url(path: String, query: Map = emptyMap()): String = + server.url(path, query) + + fun takeRequest( + timeout: Long, + unit: TimeUnit, + ): RecordedRequest? = server.takeRequest(timeout, unit) + + fun awaitQuiescence( + timeout: Long = DEFAULT_QUIESCENCE_TIMEOUT_SECONDS, + unit: TimeUnit = TimeUnit.SECONDS, + ) { + server.awaitQuiescence(timeout, unit) + } + + fun assertRequiredRoutesRequested() { + val missing = server.verifyRequiredRoutes() + if (missing.isNotEmpty()) { + throw IllegalStateException("Required routes were not requested: $missing") + } + } + + fun assertNoUnknownRequests( + maxDiagnostics: Int = DEFAULT_MAX_DIAGNOSTIC_REQUESTS, + ) { + val unknownRequests = requestJournal.unknownRequests + if (unknownRequests.isNotEmpty()) { + throw AssertionError( + "Unexpected loopback requests: ${unknownRequests.takeLast(maxDiagnostics)}", + ) + } + } + + override fun close() { + server.close() + } + + private companion object { + const val DEFAULT_QUIESCENCE_TIMEOUT_SECONDS = 10L + const val DEFAULT_MAX_DIAGNOSTIC_REQUESTS = 12 + } +} diff --git a/app/src/main/java/com/kino/puber/core/ui/PuberVM.kt b/app/src/main/java/com/kino/puber/core/ui/PuberVM.kt index 973a15c3..4a58c83e 100644 --- a/app/src/main/java/com/kino/puber/core/ui/PuberVM.kt +++ b/app/src/main/java/com/kino/puber/core/ui/PuberVM.kt @@ -27,9 +27,11 @@ import kotlinx.coroutines.launch import java.util.concurrent.atomic.AtomicBoolean import kotlin.coroutines.CoroutineContext -abstract class PuberVM(protected val router: AppRouter) : ViewModel(), +abstract class PuberVM(router: AppRouter) : ViewModel(), BackButtonDispatcher { + protected var router: AppRouter = router + private set protected open val errorHandler: ErrorHandler? = null protected abstract val initialViewState: ViewState private val mutableViewState: MutableStateFlow by lazy { @@ -134,22 +136,26 @@ abstract class PuberVM(protected val router: AppRouter) : ViewModel() } @Composable - fun collectViewState(initial: ViewState = stateValue): State { + fun collectViewState( + initial: ViewState = stateValue, + currentRouter: AppRouter = router, + ): State { ensureStarted() - DisposableEffect(this@PuberVM) { - registerBackDispatcher() + DisposableEffect(this@PuberVM, currentRouter) { + rebindRouter(currentRouter) + currentRouter.addBackDispatcher(this@PuberVM) onDispose { - removeBackDispatcher() + currentRouter.removeBackDispatcher(this@PuberVM) } } return viewState.collectAsStateWithLifecycle(initial) } - private fun registerBackDispatcher() { - router.addBackDispatcher(this) - } - - private fun removeBackDispatcher() { - router.removeBackDispatcher(this) + @VisibleForTesting + internal fun rebindRouter(currentRouter: AppRouter) { + if (router !== currentRouter) { + router.removeBackDispatcher(this) + router = currentRouter + } } } diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerControlsOverlay.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerControlsOverlay.kt index a7821756..4468e7b0 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerControlsOverlay.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerControlsOverlay.kt @@ -168,6 +168,7 @@ private fun ControlsBottomBar( onSeekBackward = actions.onSeekBackward, onTogglePlayPause = actions.onTogglePlayPause, focusRequester = focusRequesters.seekBar, + downFocusRequester = focusRequesters.firstButton, ) PlayerButtonRow( state = buttonState, diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt index 36780ca1..b3361364 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt @@ -30,6 +30,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.draw.drawBehind import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.focus.focusProperties import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.geometry.Offset import androidx.compose.ui.graphics.Brush @@ -52,6 +53,7 @@ internal fun PlayerProgressBar( onTogglePlayPause: () -> Unit = {}, modifier: Modifier = Modifier, focusRequester: FocusRequester = remember { FocusRequester() }, + downFocusRequester: FocusRequester? = null, ) { val progress = remember(currentPosition, duration) { progressOf(currentPosition, duration) } val bufferedProgress = remember(bufferedPosition, duration) { progressOf(bufferedPosition, duration) } @@ -83,6 +85,7 @@ internal fun PlayerProgressBar( shimmerProgress = shimmerProgress, isBuffering = isBuffering, focusRequester = focusRequester, + downFocusRequester = downFocusRequester, onSeekForward = onSeekForward, onSeekBackward = onSeekBackward, onTogglePlayPause = onTogglePlayPause, @@ -115,6 +118,7 @@ private fun ProgressBarRow( shimmerProgress: Float, isBuffering: Boolean, focusRequester: FocusRequester, + downFocusRequester: FocusRequester?, onSeekForward: () -> Unit, onSeekBackward: () -> Unit, onTogglePlayPause: () -> Unit, @@ -130,6 +134,7 @@ private fun ProgressBarRow( shimmerProgress = shimmerProgress, isBuffering = isBuffering, focusRequester = focusRequester, + downFocusRequester = downFocusRequester, onSeekForward = onSeekForward, onSeekBackward = onSeekBackward, onTogglePlayPause = onTogglePlayPause, @@ -164,6 +169,7 @@ private fun SeekTrack( shimmerProgress: Float, isBuffering: Boolean, focusRequester: FocusRequester, + downFocusRequester: FocusRequester?, onSeekForward: () -> Unit, onSeekBackward: () -> Unit, onTogglePlayPause: () -> Unit, @@ -172,6 +178,11 @@ private fun SeekTrack( Box( modifier = modifier .height(TRACK_TOUCH_HEIGHT) + .then( + downFocusRequester?.let { target -> + Modifier.focusProperties { down = target } + } ?: Modifier, + ) .focusRequester(focusRequester) .focusable() .onKeyEvent { keyEvent -> diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreen.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreen.kt index 5ce42302..392f5a9f 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreen.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreen.kt @@ -6,6 +6,8 @@ import androidx.compose.runtime.remember import androidx.lifecycle.Lifecycle import cafe.adriel.voyager.core.screen.ScreenKey import com.kino.puber.core.di.DIScope +import com.kino.puber.core.di.LocalPuberKoinScope +import com.kino.puber.core.ui.navigation.AppRouter import com.kino.puber.core.ui.navigation.FullscreenPuberScreen import com.kino.puber.core.ui.uikit.component.LifecycleAction import com.kino.puber.core.ui.uikit.component.ScaffoldMessage @@ -59,7 +61,8 @@ internal data class PlayerScreen(private val params: PlayerScreenParams) : Fulls @Composable override fun Content() = DIScope(scopeName = key, moduleFactory = ::buildModule) { val vm = puberViewModel() - val state by vm.collectViewState() + val currentRouter = LocalPuberKoinScope.current!!.get() + val state by vm.collectViewState(currentRouter = currentRouter) val onAction: (UIAction) -> Unit = remember(vm) { vm::onAction } LifecycleAction( diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicy.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicy.kt new file mode 100644 index 00000000..f0e57fc0 --- /dev/null +++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicy.kt @@ -0,0 +1,25 @@ +package com.kino.puber.ui.feature.player.vm + +internal class Ac3FallbackPolicy { + + private var fallbackApplied = false + + fun reset() { + fallbackApplied = false + } + + fun onDecoderInitializationFailure(positionMs: Long): Decision { + return if (fallbackApplied) { + Decision.Terminal + } else { + fallbackApplied = true + Decision.Retry(positionMs) + } + } + + sealed interface Decision { + data class Retry(val positionMs: Long) : Decision + + data object Terminal : Decision + } +} diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/ControlsStateMachine.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/ControlsStateMachine.kt index 2edc69db..e712900e 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/ControlsStateMachine.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/ControlsStateMachine.kt @@ -2,6 +2,7 @@ package com.kino.puber.ui.feature.player.vm import com.kino.puber.ui.feature.player.model.ActivePanel import com.kino.puber.ui.feature.player.model.FocusTarget +import com.kino.puber.ui.feature.player.model.PlayerContentState internal class ControlsStateMachine { @@ -102,3 +103,13 @@ internal class ControlsStateMachine { } } } + +internal fun PlayerContentState.withControlsState( + state: ControlsStateMachine.State, +): PlayerContentState { + return copy( + controlsVisible = state.controlsVisible, + controlsFocusTarget = state.focusTarget, + activePanel = state.activePanel, + ) +} diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackCallbackGate.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackCallbackGate.kt new file mode 100644 index 00000000..08427037 --- /dev/null +++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackCallbackGate.kt @@ -0,0 +1,38 @@ +package com.kino.puber.ui.feature.player.vm + +internal class PlaybackCallbackGate { + class Session internal constructor(internal val generation: Long) + + private val lock = Any() + private var callback: PlaybackControl.Callback? = null + private var generation = 0L + + fun setCallback(callback: PlaybackControl.Callback) { + synchronized(lock) { + this.callback = callback + } + } + + fun beginSession(): Session { + return synchronized(lock) { + Session(++generation) + } + } + + fun invalidate() { + synchronized(lock) { + generation += 1 + } + } + + fun dispatch( + session: Session, + action: (PlaybackControl.Callback?) -> Unit, + ) { + synchronized(lock) { + if (session.generation == generation) { + action(callback) + } + } + } +} diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt index dffb80ac..8d0977b8 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt @@ -2,7 +2,6 @@ package com.kino.puber.ui.feature.player.vm import android.content.Context import androidx.annotation.OptIn -import androidx.core.net.toUri import androidx.media3.common.AudioAttributes import androidx.media3.common.C import androidx.media3.common.Format @@ -23,7 +22,6 @@ import androidx.media3.exoplayer.source.BehindLiveWindowException import androidx.media3.extractor.DefaultExtractorsFactory import okhttp3.OkHttpClient import androidx.media3.exoplayer.ExoPlayer -import androidx.media3.exoplayer.hls.HlsMediaSource import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection import androidx.media3.exoplayer.trackselection.DefaultTrackSelector import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter @@ -35,7 +33,6 @@ import com.kino.puber.data.repository.PlayerPreferencesRepository import com.kino.puber.ui.feature.player.model.AudioTrackUIState import com.kino.puber.ui.feature.player.model.BufferPreset import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState -import java.util.Locale internal interface PlaybackControl { interface Callback : PlaybackEventSink { @@ -78,10 +75,13 @@ internal class PlaybackController( private var exoPlayer: ExoPlayer? = null private var trackSelector: DefaultTrackSelector? = null - private var callback: PlaybackControl.Callback? = null - private var ac3FallbackApplied = false + private var playerListener: Player.Listener? = null + private var callbackSession: PlaybackCallbackGate.Session? = null private var useFastDns = true private var pendingSubtitleTrack: SubtitleTrackUIState? = null + private val ac3FallbackPolicy = Ac3FallbackPolicy() + private val callbackGate = PlaybackCallbackGate() + private val mediaItemFactory = PlaybackMediaItemFactory() @OptIn(UnstableApi::class) private val bandwidthMeter = DefaultBandwidthMeter.Builder(context).build() @@ -97,49 +97,65 @@ internal class PlaybackController( get() = playbackSnapshot().shouldKeepScreenOn override val bufferedPosition: Long get() = exoPlayer?.bufferedPosition ?: 0L - private val playerListener = object : Player.Listener { - override fun onIsPlayingChanged(isPlaying: Boolean) { - notifyPlaybackState() - } - - override fun onPlaybackStateChanged(playbackState: Int) { - exoPlayer?.let { player -> - PlaybackTransitions.dispatchPlaybackState( - engine = ExoPlayerPlaybackEngine(player), - playbackState = playbackState, - sink = callback, - ) + private fun createPlayerListener(session: PlaybackCallbackGate.Session) = + object : Player.Listener { + override fun onIsPlayingChanged(isPlaying: Boolean) { + notifyPlaybackState(session) } - when (playbackState) { - Player.STATE_READY -> notifyTracksUpdated() - else -> {} + + override fun onPlaybackStateChanged(playbackState: Int) { + callbackGate.dispatch(session) { callback -> + exoPlayer?.let { player -> + PlaybackTransitions.dispatchPlaybackState( + engine = ExoPlayerPlaybackEngine(player), + playbackState = playbackState, + sink = callback, + ) + } + if (playbackState == Player.STATE_READY) { + notifyTracksUpdated(callback) + } + } } - } - override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) { - notifyPlaybackState() - } + override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) { + notifyPlaybackState(session) + } - override fun onPlaybackSuppressionReasonChanged(playbackSuppressionReason: Int) { - notifyPlaybackState() - } + override fun onPlaybackSuppressionReasonChanged(playbackSuppressionReason: Int) { + notifyPlaybackState(session) + } - override fun onTracksChanged(tracks: Tracks) { - notifyTracksUpdated() - applyPendingSubtitleSelection() - } + override fun onTracksChanged(tracks: Tracks) { + callbackGate.dispatch(session) { callback -> + notifyTracksUpdated(callback) + applyPendingSubtitleSelection() + } + } - override fun onPlayerError(error: PlaybackException) { - val cause = error.cause - when { - cause is BehindLiveWindowException -> recoverBehindLiveWindow() - cause.isAc3DecoderInitializationException() -> disableAc3AndRetry() - else -> callback?.onError( - error.localizedMessage ?: context.getString(R.string.player_error_playback) - ) + override fun onPlayerError(error: PlaybackException) { + callbackGate.dispatch(session) { callback -> + val cause = error.cause + when { + cause is BehindLiveWindowException -> recoverBehindLiveWindow() + cause.isAc3DecoderInitializationException() -> when ( + val decision = ac3FallbackPolicy.onDecoderInitializationFailure( + exoPlayer?.currentPosition ?: 0L, + ) + ) { + is Ac3FallbackPolicy.Decision.Retry -> + disableAc3AndRetry(decision.positionMs) + Ac3FallbackPolicy.Decision.Terminal -> callback?.onError( + context.getString(R.string.player_error_playback) + ) + } + else -> callback?.onError( + error.localizedMessage ?: context.getString(R.string.player_error_playback) + ) + } + } } } - } private fun recoverBehindLiveWindow() { exoPlayer?.let { player -> @@ -153,7 +169,7 @@ internal class PlaybackController( } override fun setCallback(callback: PlaybackControl.Callback) { - this.callback = callback + callbackGate.setCallback(callback) } @OptIn(UnstableApi::class) @@ -165,7 +181,7 @@ internal class PlaybackController( fastDns: Boolean, ) { release() - ac3FallbackApplied = false + ac3FallbackPolicy.reset() useFastDns = fastDns val bufferParams = DeviceBufferConfig.resolve(context, bufferPreset) @@ -215,8 +231,8 @@ internal class PlaybackController( .setHandleAudioBecomingNoisy(true) .setAudioAttributes(audioAttributes, /* handleAudioFocus = */ true) .build() - .apply { addListener(playerListener) } exoPlayer = player + bindCallbackSession(player) val mediaItem = buildMediaItem(streamUrl, subtitles) setMediaSource(player, mediaItem, streamUrl) @@ -245,6 +261,7 @@ internal class PlaybackController( override fun switchStream(streamUrl: String, subtitles: List?) { val player = exoPlayer ?: return + bindCallbackSession(player) val engine = ExoPlayerPlaybackEngine(player) PlaybackTransitions.switchStream( engine = engine, @@ -254,6 +271,15 @@ internal class PlaybackController( notifyPlaybackState() } + private fun bindCallbackSession(player: ExoPlayer) { + val session = callbackGate.beginSession() + val listener = createPlayerListener(session) + playerListener?.let(player::removeListener) + player.addListener(listener) + callbackSession = session + playerListener = listener + } + override fun play() { exoPlayer?.let { player -> PlaybackTransitions.play(ExoPlayerPlaybackEngine(player)) @@ -306,7 +332,10 @@ internal class PlaybackController( } override fun release() { - exoPlayer?.removeListener(playerListener) + callbackGate.invalidate() + callbackSession = null + playerListener?.let { exoPlayer?.removeListener(it) } + playerListener = null exoPlayer?.release() exoPlayer = null trackSelector = null @@ -314,16 +343,9 @@ internal class PlaybackController( } @OptIn(UnstableApi::class) - private fun disableAc3AndRetry() { - if (ac3FallbackApplied) { - callback?.onError(context.getString(R.string.player_error_playback)) - return - } - ac3FallbackApplied = true - + private fun disableAc3AndRetry(positionMs: Long) { val player = exoPlayer ?: return val selector = trackSelector ?: return - val position = player.currentPosition player.stop() @@ -332,39 +354,13 @@ internal class PlaybackController( .setExceedAudioConstraintsIfNecessary(false) .build() - player.seekTo(position) + player.seekTo(positionMs) player.prepare() player.playWhenReady = true } private fun buildMediaItem(streamUrl: String, subtitles: List?): MediaItem { - val builder = MediaItem.Builder().setUri(streamUrl) - if (!subtitles.isNullOrEmpty()) { - val subtitleConfigs = subtitles.map { sub -> - val stableKey = sub.url.stableSubtitleKey() - MediaItem.SubtitleConfiguration.Builder(sub.url.toUri()) - .setMimeType(subtitleMimeType(sub.url)) - .setLanguage(sub.lang) - .setLabel(stableKey) - .setId(stableKey) - .build() - } - builder.setSubtitleConfigurations(subtitleConfigs) - } - return builder.build() - } - - private fun subtitleMimeType(url: String): String { - val normalizedUrl = url - .substringBefore('?') - .substringBefore('#') - .lowercase(Locale.ROOT) - return when { - normalizedUrl.endsWith(".vtt") || normalizedUrl.endsWith(".webvtt") -> MimeTypes.TEXT_VTT - normalizedUrl.endsWith(".ass") || normalizedUrl.endsWith(".ssa") -> MimeTypes.TEXT_SSA - normalizedUrl.endsWith(".ttml") || normalizedUrl.endsWith(".xml") -> MimeTypes.APPLICATION_TTML - else -> MimeTypes.APPLICATION_SUBRIP - } + return mediaItemFactory.build(streamUrl, subtitles) } @OptIn(UnstableApi::class) @@ -388,10 +384,12 @@ internal class PlaybackController( private fun setMediaSource(player: ExoPlayer, mediaItem: MediaItem, streamUrl: String) { val dsFactory = dataSourceFactory ?: return if (streamUrl.contains(".m3u8") || streamUrl.contains("hls")) { - val hlsSource = HlsMediaSource.Factory(dsFactory) - .setAllowChunklessPreparation(true) + val hlsMediaItem = mediaItem.buildUpon() + .setMimeType(MimeTypes.APPLICATION_M3U8) + .build() + val hlsSource = createMediaSourceFactory(dsFactory) .setLoadErrorHandlingPolicy(HlsErrorPolicy()) - .createMediaSource(mediaItem) + .createMediaSource(hlsMediaItem) player.setMediaSource(hlsSource) } else { player.setMediaItem(mediaItem) @@ -464,11 +462,17 @@ internal class PlaybackController( } private fun notifyPlaybackState() { - val player = exoPlayer ?: return - PlaybackTransitions.dispatchPlaybackSnapshot( - engine = ExoPlayerPlaybackEngine(player), - sink = callback, - ) + callbackSession?.let(::notifyPlaybackState) + } + + private fun notifyPlaybackState(session: PlaybackCallbackGate.Session) { + callbackGate.dispatch(session) { callback -> + val player = exoPlayer ?: return@dispatch + PlaybackTransitions.dispatchPlaybackSnapshot( + engine = ExoPlayerPlaybackEngine(player), + sink = callback, + ) + } } private inner class ExoPlayerPlaybackEngine( @@ -530,7 +534,7 @@ internal class PlaybackController( } } - private fun notifyTracksUpdated() { + private fun notifyTracksUpdated(callback: PlaybackControl.Callback?) { val player = exoPlayer ?: return val audioGroups = player.currentTracks.groups.filter { it.type == C.TRACK_TYPE_AUDIO } if (audioGroups.isEmpty()) return diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt new file mode 100644 index 00000000..7b0bb6d3 --- /dev/null +++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt @@ -0,0 +1,40 @@ +package com.kino.puber.ui.feature.player.vm + +import androidx.core.net.toUri +import androidx.media3.common.MediaItem +import androidx.media3.common.MimeTypes +import com.kino.puber.data.api.models.SubtitleLink +import java.util.Locale + +internal class PlaybackMediaItemFactory { + + fun build(streamUrl: String, subtitles: List?): MediaItem { + val builder = MediaItem.Builder().setUri(streamUrl) + if (!subtitles.isNullOrEmpty()) { + val subtitleConfigs = subtitles.map { subtitle -> + val stableKey = subtitle.url.stableSubtitleKey() + MediaItem.SubtitleConfiguration.Builder(subtitle.url.toUri()) + .setMimeType(subtitleMimeType(subtitle.url)) + .setLanguage(subtitle.lang) + .setLabel(stableKey) + .setId(stableKey) + .build() + } + builder.setSubtitleConfigurations(subtitleConfigs) + } + return builder.build() + } + + fun subtitleMimeType(url: String): String { + val normalizedUrl = url + .substringBefore('?') + .substringBefore('#') + .lowercase(Locale.ROOT) + return when { + normalizedUrl.endsWith(".vtt") || normalizedUrl.endsWith(".webvtt") -> MimeTypes.TEXT_VTT + normalizedUrl.endsWith(".ass") || normalizedUrl.endsWith(".ssa") -> MimeTypes.TEXT_SSA + normalizedUrl.endsWith(".ttml") || normalizedUrl.endsWith(".xml") -> MimeTypes.APPLICATION_TTML + else -> MimeTypes.APPLICATION_SUBRIP + } + } +} diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt index 098b1f22..c90933a9 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt @@ -289,7 +289,9 @@ internal class PlayerVM( isMarkCurrentWatchedInFlight = watchedMutationsInFlight[token.key].orZero() > 0, ) - publishPreparedContent(contentState, resumeDialog) + controlsHideJob?.cancel() + controlsStateMachine.initialize(resumeDialogVisible = resumeDialog != null) + updateViewState(PlayerViewState.Content(contentState.withControlsState(controlsStateMachine.state))) autoMarkHandledToken = token.takeIf { resolved.isCurrentMediaWatched } episodeSwitchInProgress = false initializePlayer(savedPosition = if (resumeDialog != null) null else 0L) @@ -298,19 +300,6 @@ internal class PlayerVM( loadSkipSegments(item, resolved.seasonNumber, resolved.episodeNumber, token) } - private fun publishPreparedContent( - contentState: PlayerContentState, - resumeDialog: ResumeDialogState?, - ) { - controlsHideJob?.cancel() - controlsStateMachine.initialize(resumeDialogVisible = resumeDialog != null) - updateViewState( - PlayerViewState.Content( - contentState.withControlsState(controlsStateMachine.state), - ), - ) - } - private fun isCurrentPrepare(generation: Long): Boolean { return !closing && generation == mediaGeneration } @@ -494,12 +483,6 @@ internal class PlayerVM( processEffects(effects) } - private fun showControlsPersistently(focusTarget: FocusTarget) { - val effects = controlsStateMachine.showControlsPersistently(focusTarget) - applyControlsState() - processEffects(effects) - } - private fun hideControls() { val effects = controlsStateMachine.hideControls() applyControlsState() @@ -528,10 +511,7 @@ internal class PlayerVM( } private fun applyControlsState() { - val cs = controlsStateMachine.state - updateContent { - withControlsState(cs) - } + updateContent { withControlsState(controlsStateMachine.state) } } private fun processEffects(effects: List) { @@ -999,7 +979,11 @@ internal class PlayerVM( !content.isMovie && content.hasNextEpisode && content.nextEpisodeCountdown == null -> startNextEpisodeCountdown() - !content.isMovie -> showControlsPersistently(FocusTarget.Buttons) + !content.isMovie -> { + val effects = controlsStateMachine.showControlsPersistently(FocusTarget.Buttons) + applyControlsState() + processEffects(effects) + } } } @@ -1048,16 +1032,6 @@ internal class PlayerVM( scheduleControlsHide() } - private fun PlayerContentState.withControlsState( - state: ControlsStateMachine.State, - ): PlayerContentState { - return copy( - controlsVisible = state.controlsVisible, - controlsFocusTarget = state.focusTarget, - activePanel = state.activePanel, - ) - } - private fun pauseForBackground() { val wasPlayRequested = playbackController.playbackIntent == PlaybackIntent.PlayRequested if (wasPlayRequested) { diff --git a/app/src/test/kotlin/com/kino/puber/data/api/MockWebServerTestSupport.kt b/app/src/test/kotlin/com/kino/puber/data/api/MockWebServerTestSupport.kt index 67505286..7e1c32d9 100644 --- a/app/src/test/kotlin/com/kino/puber/data/api/MockWebServerTestSupport.kt +++ b/app/src/test/kotlin/com/kino/puber/data/api/MockWebServerTestSupport.kt @@ -1,41 +1,39 @@ package com.kino.puber.data.api -import java.net.InetAddress -import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.TimeUnit -import mockwebserver3.Dispatcher import mockwebserver3.MockResponse import mockwebserver3.MockResponseBody -import mockwebserver3.MockWebServer import mockwebserver3.RecordedRequest +import com.kino.puber.playertestfixtures.server.HermeticTestServer +import com.kino.puber.playertestfixtures.server.QueryMatchMode +import com.kino.puber.playertestfixtures.server.ResponsePlan import okio.Buffer import okio.BufferedSink internal class MockWebServerTestSupport : AutoCloseable { - private val routes = ConcurrentHashMap MockResponse>() - private val server = MockWebServer().apply { - dispatcher = object : Dispatcher() { - override fun dispatch(request: RecordedRequest): MockResponse = - routes[request.url.encodedPath]?.invoke(request) - ?: response( - status = 404, - body = """{"error":"unexpected test route"}""", - ) - } - } + private val server = HermeticTestServer() init { - server.start(InetAddress.getLoopbackAddress(), 0) + server.start() } val requestCount: Int - get() = server.requestCount + get() = server.requestJournal.entries.size - fun url(path: String): String = server.url(path).toString() + fun url(path: String): String = server.url(path) fun route(path: String, handler: (RecordedRequest) -> MockResponse) { - routes[normalizePath(path)] = handler + val normalizedPath = normalizePath(path) + server.addRoute( + server.route( + id = normalizedPath, + method = "*", + path = normalizedPath, + queryMode = QueryMatchMode.Contains, + response = ResponsePlan.Dynamic(handler), + ), + ) } fun response(status: Int, body: String): MockResponse = diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicyTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicyTest.kt new file mode 100644 index 00000000..0606845f --- /dev/null +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/Ac3FallbackPolicyTest.kt @@ -0,0 +1,34 @@ +package com.kino.puber.ui.feature.player.vm + +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test + +internal class Ac3FallbackPolicyTest { + + @Test + fun decoderFailure_retriesOnceAtCurrentPosition_thenBecomesTerminal() { + val policy = Ac3FallbackPolicy() + + assertEquals( + Ac3FallbackPolicy.Decision.Retry(positionMs = 137_000L), + policy.onDecoderInitializationFailure(positionMs = 137_000L), + ) + assertEquals( + Ac3FallbackPolicy.Decision.Terminal, + policy.onDecoderInitializationFailure(positionMs = 141_000L), + ) + } + + @Test + fun reset_startsANewFallbackWindow() { + val policy = Ac3FallbackPolicy() + policy.onDecoderInitializationFailure(positionMs = 10_000L) + + policy.reset() + + assertEquals( + Ac3FallbackPolicy.Decision.Retry(positionMs = 25_000L), + policy.onDecoderInitializationFailure(positionMs = 25_000L), + ) + } +} diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt new file mode 100644 index 00000000..bbb47ae2 --- /dev/null +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt @@ -0,0 +1,64 @@ +package com.kino.puber.ui.feature.player.vm + +import com.kino.puber.ui.feature.player.model.AudioTrackUIState +import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test + +internal class AudioTrackPreferenceResolverTest { + + private val resolver = AudioTrackPreferenceResolver() + + @Test + fun findAudioTrackIndex_prefersExactThenNormalizedLabel() { + val tracks = listOf( + AudioTrackUIState(0, "01. Original (ENG)", "eng"), + AudioTrackUIState(1, "02. Original (ENG)", "eng"), + AudioTrackUIState(2, "03. ŠœŠ½Š¾Š³Š¾Š³Š¾Š»Š¾ŃŃ‹Š¹. Red Head Sound (RUS)", "rus"), + ) + + assertEquals(1, resolver.findAudioTrackIndex(tracks, "02. Original (ENG)", "eng")) + assertEquals(0, resolver.findAudioTrackIndex(tracks, "1. Original (ENG)", "eng")) + assertEquals(2, resolver.findAudioTrackIndex(tracks, "99. ŠœŠ½Š¾Š³Š¾Š³Š¾Š»Š¾ŃŃ‹Š¹. Other (RUS)", "rus")) + } + + @Test + fun findAudioTrackIndex_fallsBackToLanguageAndReturnsNoMatch() { + val tracks = listOf( + AudioTrackUIState(0, "English", "eng"), + AudioTrackUIState(1, "Š ŃƒŃŃŠŗŠøŠ¹", "rus"), + ) + + assertEquals(1, resolver.findAudioTrackIndex(tracks, null, "rus")) + assertEquals(-1, resolver.findAudioTrackIndex(tracks, null, "deu")) + } + + @Test + fun findSubtitleTrackIndex_matchesSignedUrlByStablePathBeforeLanguage() { + val tracks = listOf( + SubtitleTrackUIState(0, "Off", "", ""), + SubtitleTrackUIState(1, "Russian", "rus", "https://cdn/subtitles/rus.vtt?token=new"), + SubtitleTrackUIState(2, "Russian SDH", "rus", "https://cdn/subtitles/rus-sdh.vtt?token=new"), + ) + + assertEquals( + 1, + resolver.findSubtitleTrackIndex( + tracks = tracks, + preferredLang = "rus", + preferredUrl = "https://cdn/subtitles/rus.vtt?token=old#signed", + ), + ) + } + + @Test + fun findSubtitleTrackIndex_rejectsAmbiguousLanguageWithoutUrl() { + val tracks = listOf( + SubtitleTrackUIState(0, "Off", "", ""), + SubtitleTrackUIState(1, "Russian", "rus", "https://cdn/subtitles/rus.vtt"), + SubtitleTrackUIState(2, "Russian SDH", "rus", "https://cdn/subtitles/rus-sdh.vtt"), + ) + + assertEquals(-1, resolver.findSubtitleTrackIndex(tracks, "rus", null)) + } +} diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/HlsErrorPolicyTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/HlsErrorPolicyTest.kt new file mode 100644 index 00000000..2981c502 --- /dev/null +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/HlsErrorPolicyTest.kt @@ -0,0 +1,105 @@ +package com.kino.puber.ui.feature.player.vm + +import androidx.media3.common.C +import androidx.media3.common.ParserException +import androidx.media3.common.util.UnstableApi +import androidx.media3.datasource.HttpDataSource +import androidx.media3.exoplayer.source.LoadEventInfo +import androidx.media3.exoplayer.source.MediaLoadData +import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy +import java.io.FileNotFoundException +import java.io.IOException +import io.mockk.every +import io.mockk.mockk +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNull +import org.junit.jupiter.api.Test + +@OptIn(UnstableApi::class) +internal class HlsErrorPolicyTest { + + private val policy = HlsErrorPolicy() + + @Test + fun retryDelay_isLinearAndCapped_forRetryableErrors() { + assertEquals(1_000L, policy.getRetryDelayMsFor(errorInfo(errorCount = 1))) + assertEquals(2_000L, policy.getRetryDelayMsFor(errorInfo(errorCount = 2))) + assertEquals(5_000L, policy.getRetryDelayMsFor(errorInfo(errorCount = 5))) + assertEquals(5_000L, policy.getRetryDelayMsFor(errorInfo(errorCount = 9))) + assertEquals(1_000L, policy.getRetryDelayMsFor(errorInfo(invalidResponse(404)))) + } + + @Test + fun retryDelay_isUnset_forParserAndFileNotFoundErrors() { + assertEquals( + C.TIME_UNSET, + policy.getRetryDelayMsFor(errorInfo(exception = ParserException.createForMalformedManifest("bad", null))), + ) + assertEquals( + C.TIME_UNSET, + policy.getRetryDelayMsFor(errorInfo(exception = FileNotFoundException("missing"))), + ) + } + + @Test + fun minimumRetryCount_isFive() { + assertEquals(5, policy.getMinimumLoadableRetryCount(C.DATA_TYPE_MEDIA)) + } + + @Test + fun fallback_selectsTrackForBadRequestAndBadGateway_whenTrackIsAvailable() { + listOf(400, 502).forEach { status -> + val fallback = policy.getFallbackSelectionFor( + fallbackOptions(numberOfTracks = 2), + errorInfo(exception = invalidResponse(status)), + ) + + assertEquals(LoadErrorHandlingPolicy.FALLBACK_TYPE_TRACK, fallback?.type) + assertEquals(60_000L, fallback?.exclusionDurationMs) + } + } + + @Test + fun fallback_isAbsent_whenStatusOrTrackAvailabilityDoesNotQualify() { + assertNull( + policy.getFallbackSelectionFor( + fallbackOptions(numberOfTracks = 2), + errorInfo(exception = invalidResponse(404)), + ), + ) + assertNull( + policy.getFallbackSelectionFor( + fallbackOptions(numberOfTracks = 1), + errorInfo(exception = invalidResponse(400)), + ), + ) + } + + private fun errorInfo( + exception: IOException = IOException("transient"), + errorCount: Int = 1, + ): LoadErrorHandlingPolicy.LoadErrorInfo { + return LoadErrorHandlingPolicy.LoadErrorInfo( + mockk(), + mockk(), + exception, + errorCount, + ) + } + + private fun fallbackOptions(numberOfTracks: Int) = LoadErrorHandlingPolicy.FallbackOptions( + 1, + 0, + numberOfTracks, + 0, + ) + + private fun invalidResponse(status: Int) = HttpDataSource.InvalidResponseCodeException( + status, + "failure", + null, + emptyMap(), + mockk(), + byteArrayOf(), + ) +} diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt new file mode 100644 index 00000000..61acd1fa --- /dev/null +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt @@ -0,0 +1,175 @@ +package com.kino.puber.ui.feature.player.vm + +import android.app.Application +import androidx.media3.common.MediaItem +import androidx.media3.common.PlaybackException +import androidx.media3.common.Player +import androidx.media3.common.TrackSelectionParameters +import androidx.media3.common.Tracks +import androidx.media3.datasource.DataSource +import androidx.media3.datasource.cache.Cache +import androidx.media3.exoplayer.ExoPlayer +import com.kino.puber.data.repository.PlayerPreferencesRepository +import com.kino.puber.ui.feature.player.model.AudioTrackUIState +import io.mockk.every +import io.mockk.just +import io.mockk.mockk +import io.mockk.runs +import okhttp3.OkHttpClient +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(application = Application::class, sdk = [35]) +internal class PlaybackControllerCallbackGenerationTest { + + @Test + fun rapidSwitches_rejectSupersededProductionListenersAndAdmitCurrentCallbacks() { + val context = RuntimeEnvironment.getApplication() + val player = mockk(relaxed = true) + val addedListeners = mutableListOf() + val removedListeners = mutableListOf() + val selectedStreams = mutableListOf() + var currentPosition = C_POSITION_MS + var duration = DURATION_MS + var bufferedPosition = C_BUFFERED_POSITION_MS + var isPlaying = true + var playWhenReady = true + var playbackState = Player.STATE_READY + var playbackSuppressionReason = Player.PLAYBACK_SUPPRESSION_REASON_NONE + var trackSelectionParameters = mockk(relaxed = true) + + every { player.addListener(capture(addedListeners)) } just runs + every { player.removeListener(capture(removedListeners)) } just runs + every { player.setMediaItem(capture(selectedStreams)) } just runs + every { player.currentPosition } answers { currentPosition } + every { player.duration } answers { duration } + every { player.bufferedPosition } answers { bufferedPosition } + every { player.isPlaying } answers { isPlaying } + every { player.playWhenReady } answers { playWhenReady } + every { player.playWhenReady = any() } answers { playWhenReady = firstArg() } + every { player.playbackState } answers { playbackState } + every { player.playbackSuppressionReason } answers { playbackSuppressionReason } + every { player.trackSelectionParameters } answers { trackSelectionParameters } + every { player.trackSelectionParameters = any() } answers { + trackSelectionParameters = firstArg() + } + every { player.currentTracks } returns Tracks.EMPTY + + val callback = RecordingCallback() + val controller = PlaybackController( + context = context, + okHttpClient = OkHttpClient(), + mediaCache = mockk(relaxed = true), + playerPreferencesRepository = PlayerPreferencesRepository(context), + ) + controller.setCallback(callback) + controller.setPrivateField("exoPlayer", player) + controller.setPrivateField("dataSourceFactory", mockk(relaxed = true)) + + controller.switchStream(STREAM_A, subtitles = null) + val listenerA = addedListeners.single() + controller.switchStream(STREAM_B, subtitles = null) + val listenerB = addedListeners.last() + controller.switchStream(STREAM_C, subtitles = null) + val listenerC = addedListeners.last() + + assertEquals(listOf(STREAM_A, STREAM_B, STREAM_C), selectedStreams.map(::streamUri)) + assertEquals(listOf(listenerA, listenerB), removedListeners) + assertEquals(3, addedListeners.distinct().size) + + callback.clear() + listenerC.onPlaybackStateChanged(Player.STATE_READY) + val admittedCState = callback.snapshots.single() + assertEquals(C_POSITION_MS, admittedCState.position) + assertEquals(PlaybackIntent.PlayRequested, admittedCState.intent) + assertEquals(false, admittedCState.isBuffering) + + repeat(POST_C_STABILITY_DELIVERIES) { + listenerA.onPlayerError(playbackError(STALE_A_ERROR)) + currentPosition = B_POSITION_MS + bufferedPosition = B_BUFFERED_POSITION_MS + isPlaying = false + playWhenReady = false + playbackState = Player.STATE_BUFFERING + listenerB.onPlaybackStateChanged(Player.STATE_BUFFERING) + currentPosition = C_POSITION_MS + bufferedPosition = C_BUFFERED_POSITION_MS + isPlaying = true + playWhenReady = true + playbackState = Player.STATE_READY + } + + assertEquals(listOf(admittedCState), callback.snapshots) + assertEquals(emptyList(), callback.errors) + assertEquals(STREAM_C, streamUri(selectedStreams.last())) + assertEquals(C_POSITION_MS, controller.currentPosition) + assertEquals(PlaybackIntent.PlayRequested, controller.playbackIntent) + assertEquals(true, controller.isPlaying) + assertSame(listenerC, addedListeners.last()) + + listenerC.onPlaybackStateChanged(Player.STATE_READY) + listenerC.onPlayerError(playbackError(CURRENT_C_ERROR)) + + assertEquals(listOf(admittedCState, admittedCState), callback.snapshots) + assertEquals(listOf(CURRENT_C_ERROR), callback.errors) + } + + private fun playbackError(message: String) = PlaybackException( + message, + null, + PlaybackException.ERROR_CODE_UNSPECIFIED, + ) + + private fun streamUri(mediaItem: MediaItem): String { + return mediaItem.localConfiguration?.uri.toString() + } + + private fun PlaybackController.setPrivateField(name: String, value: Any) { + PlaybackController::class.java.getDeclaredField(name).apply { + isAccessible = true + set(this@setPrivateField, value) + } + } + + private class RecordingCallback : PlaybackControl.Callback { + val snapshots = mutableListOf() + val errors = mutableListOf() + + override fun onPlaybackStateChanged(snapshot: PlaybackSnapshot) { + snapshots += snapshot + } + + override fun onPlaybackEnded() = Unit + + override fun onTracksUpdated(audioTracks: List, selectedIndex: Int) = Unit + + override fun onError(message: String) { + errors += message + } + + fun clear() { + snapshots.clear() + errors.clear() + } + } + + private companion object { + const val STREAM_A = "http://127.0.0.1/quality-a.mp4" + const val STREAM_B = "http://127.0.0.1/quality-b.mp4" + const val STREAM_C = "http://127.0.0.1/quality-c.mp4" + const val STALE_A_ERROR = "Stale A error" + const val CURRENT_C_ERROR = "Current C error" + const val C_POSITION_MS = 30_000L + const val C_BUFFERED_POSITION_MS = 90_000L + const val B_POSITION_MS = 5_000L + const val B_BUFFERED_POSITION_MS = 10_000L + const val DURATION_MS = 2_400_000L + const val POST_C_STABILITY_DELIVERIES = 3 + } +} diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt new file mode 100644 index 00000000..60b626b5 --- /dev/null +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt @@ -0,0 +1,57 @@ +package com.kino.puber.ui.feature.player.vm + +import android.app.Application +import androidx.media3.common.MimeTypes +import com.kino.puber.data.api.models.SubtitleLink +import org.junit.Assert.assertEquals +import org.junit.runner.RunWith +import org.junit.Test +import org.robolectric.annotation.Config +import org.robolectric.RobolectricTestRunner + +@RunWith(RobolectricTestRunner::class) +@Config(application = Application::class, sdk = [35]) +internal class PlaybackMediaItemFactoryTest { + + private val factory = PlaybackMediaItemFactory() + + @Test + fun build_preservesStreamAndBuildsStableSubtitleConfigurations() { + val item = factory.build( + streamUrl = "http://127.0.0.1:8080/video.m3u8", + subtitles = listOf( + SubtitleLink( + lang = "rus", + url = "http://127.0.0.1:8080/subtitles/rus.vtt?token=secret#cue", + ), + SubtitleLink( + lang = "eng", + url = "http://127.0.0.1:8080/subtitles/eng.webvtt?expires=123", + ), + ), + ) + + assertEquals("http://127.0.0.1:8080/video.m3u8", item.localConfiguration?.uri.toString()) + val subtitles = item.localConfiguration?.subtitleConfigurations.orEmpty() + assertEquals(listOf("rus", "eng"), subtitles.map { it.language }) + assertEquals(listOf("rus.vtt", "eng.webvtt"), subtitles.map { it.id.orEmpty() }) + assertEquals(listOf("rus.vtt", "eng.webvtt"), subtitles.map { it.label }) + assertEquals(listOf(MimeTypes.TEXT_VTT, MimeTypes.TEXT_VTT), subtitles.map { it.mimeType }) + assertEquals( + listOf( + "http://127.0.0.1:8080/subtitles/rus.vtt?token=secret#cue", + "http://127.0.0.1:8080/subtitles/eng.webvtt?expires=123", + ), + subtitles.map { it.uri.toString() }, + ) + } + + @Test + fun subtitleMimeType_handlesQueryFragmentAndFallbackExtensions() { + assertEquals(MimeTypes.TEXT_VTT, factory.subtitleMimeType("https://test/subtitles/a.VTT?sig=1#x")) + assertEquals(MimeTypes.TEXT_VTT, factory.subtitleMimeType("https://test/subtitles/a.webvtt")) + assertEquals(MimeTypes.TEXT_SSA, factory.subtitleMimeType("https://test/subtitles/a.ssa")) + assertEquals(MimeTypes.APPLICATION_TTML, factory.subtitleMimeType("https://test/subtitles/a.XML#cue")) + assertEquals(MimeTypes.APPLICATION_SUBRIP, factory.subtitleMimeType("https://test/subtitles/a.txt")) + } +} diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt new file mode 100644 index 00000000..fcc75888 --- /dev/null +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt @@ -0,0 +1,183 @@ +package com.kino.puber.ui.feature.player.vm + +import com.kino.puber.data.api.models.SubtitleLink +import com.kino.puber.ui.feature.player.model.BufferPreset +import com.kino.puber.ui.feature.player.model.PlayerAction +import com.kino.puber.ui.feature.player.model.PlayerViewState +import com.kino.puber.ui.feature.player.model.QualityUIState +import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState +import com.kino.puber.util.MainDispatcherExtension +import io.mockk.coEvery +import io.mockk.every +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertTrue +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.RegisterExtension + +internal class PlayerVMCallbackGenerationTest : PlayerVMTestFixture() { + + companion object { + @JvmField + @RegisterExtension + val mainDispatcher = MainDispatcherExtension() + + private const val POST_C_STABILITY_DELIVERIES = 3 + } + + @Test + fun callbackAfterRelease_doesNotMutateReloadedStateOrLeakMappedError() { + val controlledPlayback = ControlledPlaybackControl() + playbackController = controlledPlayback + val vm = startedVM() + val releasedSession = controlledPlayback.currentSession + + controlledPlayback.deliverError(releasedSession, "Mapped host error") + assertEquals( + PlayerViewState.Error("Mapped host error"), + vm.testStateValue, + ) + + vm.onAction(PlayerAction.RetryPlayback) + val reloadedState = vm.testStateValue + assertTrue(reloadedState is PlayerViewState.Content) + + controlledPlayback.deliverError(releasedSession, "Stale released error") + + assertEquals(reloadedState, vm.testStateValue) + assertEquals( + listOf("Mapped host error"), + controlledPlayback.deliveredErrors, + ) + } + + @Test + fun rapidQualitySwitches_ignoreSupersededCallbacksAfterFinalStreamState() { + val controlledPlayback = ControlledPlaybackControl() + playbackController = controlledPlayback + coEvery { contentStateFactory.build(any(), any(), any(), any(), any(), any()) } returns + testContentState.copy( + qualities = listOf( + QualityUIState(0, "A", 1, 640, 360), + QualityUIState(1, "B", 2, 1280, 720), + QualityUIState(2, "C", 3, 1920, 1080), + ), + ) + every { interactor.selectStreamUrl(any(), any()) } answers { + "https://test/${secondArg()}.m3u8" + } + val vm = startedVM() + val sessionA = controlledPlayback.currentSession + + vm.onAction(PlayerAction.SelectQuality(1)) + val sessionB = controlledPlayback.currentSession + vm.onAction(PlayerAction.SelectQuality(2)) + val sessionC = controlledPlayback.currentSession + controlledPlayback.deliverPlaybackState( + sessionC, + PlaybackSnapshot( + isPlaying = true, + intent = PlaybackIntent.PlayRequested, + shouldKeepScreenOn = true, + shouldResumeAfterStreamSwitch = true, + isBuffering = false, + position = 30_000L, + duration = 2_400_000L, + buffered = 90_000L, + ), + ) + val finalStreamState = contentState(vm) + assertEquals(2, finalStreamState.selectedQualityIndex) + assertEquals(30_000L, finalStreamState.currentPosition) + + repeat(POST_C_STABILITY_DELIVERIES) { + controlledPlayback.deliverError(sessionA, "Stale A error") + controlledPlayback.deliverPlaybackState( + sessionB, + PlaybackSnapshot( + isPlaying = false, + intent = PlaybackIntent.Paused, + shouldKeepScreenOn = false, + shouldResumeAfterStreamSwitch = false, + isBuffering = true, + position = 5_000L, + duration = 2_400_000L, + buffered = 10_000L, + ), + ) + } + + assertEquals(finalStreamState, contentState(vm)) + assertEquals(listOf("state"), controlledPlayback.deliveredEvents) + } + + private class ControlledPlaybackControl : PlaybackControl { + private val callbackGate = PlaybackCallbackGate() + var currentSession = callbackGate.beginSession() + private set + val deliveredErrors = mutableListOf() + val deliveredEvents = mutableListOf() + + override val currentPosition: Long = 0L + override val duration: Long = 2_400_000L + override val isPlaying: Boolean = true + override val playbackIntent: PlaybackIntent = PlaybackIntent.PlayRequested + override val shouldKeepScreenOn: Boolean = true + override val bufferedPosition: Long = 0L + + override fun setCallback(callback: PlaybackControl.Callback) { + callbackGate.setCallback(callback) + } + + override fun prepare( + streamUrl: String, + subtitles: List?, + startPosition: Long?, + bufferPreset: BufferPreset, + fastDns: Boolean, + ) { + currentSession = callbackGate.beginSession() + } + + override fun switchStream(streamUrl: String, subtitles: List?) { + currentSession = callbackGate.beginSession() + } + + override fun play() = Unit + + override fun pause() = Unit + + override fun seekTo(positionMs: Long) = Unit + + override fun setSpeed(speed: Float) = Unit + + override fun selectAudioTrack(groupIndex: Int) = Unit + + override fun selectSubtitle(track: SubtitleTrackUIState?) = Unit + + override fun release() { + callbackGate.invalidate() + } + + fun deliverError(session: PlaybackCallbackGate.Session, message: String) { + callbackGate.dispatch(session) { callback -> + callback?.onError(message) + if (callback != null) { + deliveredErrors += message + deliveredEvents += "error" + } + } + } + + fun deliverPlaybackState( + session: PlaybackCallbackGate.Session, + snapshot: PlaybackSnapshot, + ) { + callbackGate.dispatch(session) { callback -> + callback?.onPlaybackStateChanged(snapshot) + if (callback != null) { + deliveredEvents += "state" + } + } + } + } +} diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt index c7f2bdc4..c4ccc14c 100644 --- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt @@ -4,6 +4,7 @@ import com.kino.puber.R import com.kino.puber.core.content.ContentChangeSet import com.kino.puber.core.content.ContentChangeType import com.kino.puber.core.error.DefaultErrorHandler +import com.kino.puber.core.ui.navigation.AppRouter import com.kino.puber.core.ui.navigation.RESULT_CONTENT_CHANGED import com.kino.puber.data.api.models.Item import com.kino.puber.data.api.models.ItemType @@ -23,6 +24,7 @@ import io.ktor.client.plugins.HttpRequestTimeoutException import io.mockk.coEvery import io.mockk.coVerify import io.mockk.every +import io.mockk.mockk import io.mockk.verify import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.NonCancellable @@ -317,6 +319,22 @@ internal class PlayerVMTest : PlayerVMTestFixture() { assertEquals(ActivePanel.None, contentState(vm).activePanel) } + @Test + fun rebindRouter_routesPanelBackThroughRecreatedFlowRouter() { + val previousRouter = router + val recreatedRouter = mockk(relaxed = true) + val vm = startedVM() + vm.onAction(PlayerAction.OpenAudioSubtitlesPanel) + + vm.rebindRouter(recreatedRouter) + vm.onBackPressed() + + assertEquals(ActivePanel.None, contentState(vm).activePanel) + verify { previousRouter.removeBackDispatcher(vm) } + verify { recreatedRouter.addBackDispatcher(vm) } + verify(exactly = 0) { previousRouter.addBackDispatcher(vm) } + } + // endregion // region Error diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentityTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentityTest.kt new file mode 100644 index 00000000..e229621d --- /dev/null +++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentityTest.kt @@ -0,0 +1,33 @@ +package com.kino.puber.ui.feature.player.vm + +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test + +internal class SubtitleTrackIdentityTest { + + @Test + fun stableSubtitleKey_excludesSignedQueryAndFragment() { + assertEquals( + "episode-1.vtt", + "https://cdn.example/subtitles/episode-1.vtt?token=secret#captions".stableSubtitleKey(), + ) + } + + @Test + fun stableSubtitleKey_keepsDistinctSubtitlePaths() { + assertEquals( + "episode-1.vtt", + "https://cdn.example/subtitles/episode-1.vtt?expires=1".stableSubtitleKey(), + ) + assertEquals( + "episode-1-forced.vtt", + "https://cdn.example/subtitles/episode-1-forced.vtt?expires=1".stableSubtitleKey(), + ) + } + + @Test + fun stableSubtitleKey_handlesEmptyAndNonStandardUrls() { + assertEquals("", "".stableSubtitleKey()) + assertEquals("captions.vtt", "captions.vtt?token=1#cue".stableSubtitleKey()) + } +} diff --git a/baselineprofile/build.gradle.kts b/baselineprofile/build.gradle.kts index 22186d52..1db0a895 100644 --- a/baselineprofile/build.gradle.kts +++ b/baselineprofile/build.gradle.kts @@ -42,4 +42,5 @@ dependencies { implementation(libs.androidx.uiautomator) implementation(libs.androidx.test.runner) implementation(libs.mockwebserver3) + implementation(project(":player-test-fixtures")) } diff --git a/baselineprofile/src/main/AndroidManifest.xml b/baselineprofile/src/main/AndroidManifest.xml new file mode 100644 index 00000000..72559ce3 --- /dev/null +++ b/baselineprofile/src/main/AndroidManifest.xml @@ -0,0 +1,4 @@ + diff --git a/baselineprofile/src/main/java/com/kino/puber/baselineprofile/BaselineMockBackend.kt b/baselineprofile/src/main/java/com/kino/puber/baselineprofile/BaselineMockBackend.kt index 7f4f9530..aae38225 100644 --- a/baselineprofile/src/main/java/com/kino/puber/baselineprofile/BaselineMockBackend.kt +++ b/baselineprofile/src/main/java/com/kino/puber/baselineprofile/BaselineMockBackend.kt @@ -3,13 +3,14 @@ package com.kino.puber.baselineprofile import android.content.Context import java.io.Closeable import java.util.concurrent.atomic.AtomicLong -import mockwebserver3.Dispatcher -import mockwebserver3.MockResponse -import mockwebserver3.MockWebServer import mockwebserver3.RecordedRequest import okhttp3.HttpUrl import org.json.JSONArray import org.json.JSONObject +import com.kino.puber.playertestfixtures.server.HermeticRequestJournal +import com.kino.puber.playertestfixtures.server.HermeticTestServer +import com.kino.puber.playertestfixtures.server.QueryMatchMode as HermeticQueryMatchMode +import com.kino.puber.playertestfixtures.server.ResponsePlan /** * A route-based backend for profile and macrobenchmark journeys. @@ -23,17 +24,15 @@ class BaselineMockBackend( private val fixtures: BaselineFixtures = BaselineFixtures.synthetic(), ) : Closeable { - private val server = MockWebServer() + private val server = HermeticTestServer(port) private val generation = AtomicLong(0) private val lock = Any() private var activeScenario = BaselineScenario.Startup private var activeRoutes: List = emptyList() - private val matchedCounts = linkedMapOf() - private val unknownRequests = mutableListOf() private var started = false val baseUrl: String - get() = server.url("/").toString() + get() = server.baseUrl val generationId: Long get() = generation.get() @@ -45,10 +44,13 @@ class BaselineMockBackend( val requestJournal: BaselineRequestJournal get() = synchronized(lock) { + val snapshot = server.requestJournal BaselineRequestJournal( generationId = generationId, - matched = matchedCounts.toMap(), - unknown = unknownRequests.toList(), + matched = activeRoutes.associateWith { route -> + snapshot.matchedRoutes[route.description] ?: 0 + }, + unknown = snapshot.unknownRequests.map(BaselineRequest::from), ) } @@ -56,8 +58,7 @@ class BaselineMockBackend( synchronized(lock) { check(!started) { "BaselineMockBackend is already started" } fixtures.validate() - server.dispatcher = routeDispatcher() - server.start(port) + server.start() started = true reset(activeScenario) } @@ -82,7 +83,8 @@ class BaselineMockBackend( while (System.nanoTime() < deadline) { val observed = synchronized(lock) { val route = activeRoutes.firstOrNull(::isStartupHomeRoute) - route != null && (matchedCounts[route] ?: 0) > 0 + route != null && + (server.requestJournal.matchedRoutes[route.description] ?: 0) > 0 } if (observed) { return @@ -101,27 +103,47 @@ class BaselineMockBackend( check(started) { "Call start() before reset()" } activeScenario = scenario activeRoutes = routesFor(scenario) - matchedCounts.clear() - unknownRequests.clear() + server.reset( + activeRoutes.map { route -> + server.route( + id = route.description, + method = route.method, + path = route.path, + query = route.query, + queryMode = route.queryMode.toHermetic(), + response = ResponsePlan.Text( + status = 200, + body = route.body, + contentType = "application/json; charset=utf-8", + ), + required = route.required, + minimumRequests = route.minimumRequests, + ) + }, + ) generation.incrementAndGet() } } fun verify(): BaselineVerification { synchronized(lock) { + val snapshot = server.requestJournal + val matched = activeRoutes.associateWith { route -> + snapshot.matchedRoutes[route.description] ?: 0 + } val missing = activeRoutes - .filter { it.required && (matchedCounts[it] ?: 0) < it.minimumRequests } + .filter { it.required && (matched[it] ?: 0) < it.minimumRequests } .map { it.description } .toMutableList() if (activeScenario == BaselineScenario.BrowseAndDetails) { - val detailIds = matchedCounts + val detailIds = matched .filter { (route, count) -> count > 0 && route.path.startsWith("/v1/items/") && route.path.removePrefix("/v1/items/").toIntOrNull() != null } .map { it.key.path.removePrefix("/v1/items/").toInt() } .toSet() - val similarIds = matchedCounts + val similarIds = matched .filter { (route, count) -> count > 0 && route.path == "/v1/items/similar" } @@ -134,12 +156,12 @@ class BaselineMockBackend( return BaselineVerification( generationId = generationId, scenario = activeScenario, - matchedRequests = matchedCounts.values.sum(), - matchedRoutes = matchedCounts + matchedRequests = matched.values.sum(), + matchedRoutes = matched .filterValues { it > 0 } .entries .associate { (route, count) -> route.description to count }, - unknownRequests = unknownRequests.toList(), + unknownRequests = snapshot.unknownRequests.map(BaselineRequest::from), missingRequiredRoutes = missing, ) } @@ -147,9 +169,7 @@ class BaselineMockBackend( fun url(route: BaselineMockRoute): String { check(started) { "Call start() before url()" } - return server.url(route.path).newBuilder().apply { - route.query.forEach { (name, value) -> addQueryParameter(name, value) } - }.build().toString() + return server.url(route.path, route.query) } override fun close() { @@ -160,23 +180,6 @@ class BaselineMockBackend( } } - private fun routeDispatcher() = object : Dispatcher() { - override fun dispatch(request: RecordedRequest): MockResponse { - synchronized(lock) { - val route = activeRoutes.firstOrNull { it.matches(request) } - if (route == null) { - unknownRequests += BaselineRequest.from(request) - return jsonResponse( - code = 404, - body = """{"error":"unknown baseline route"}""", - ) - } - matchedCounts[route] = (matchedCounts[route] ?: 0) + 1 - return jsonResponse(body = route.body) - } - } - } - private fun routesFor(scenario: BaselineScenario): List { val routes = mutableListOf() fun route( @@ -321,13 +324,6 @@ class BaselineMockBackend( return routes } - private fun jsonResponse(code: Int = 200, body: String): MockResponse = - MockResponse.Builder() - .code(code) - .addHeader("Content-Type", "application/json; charset=utf-8") - .body(body) - .build() - private companion object { const val STARTUP_HOME_PATH = "/v1/items/fresh" const val STARTUP_HOME_SHORTCUT = "fresh" @@ -393,6 +389,9 @@ data class BaselineRequest( companion object { fun from(request: RecordedRequest): BaselineRequest = BaselineRequest(request.method, request.url.encodedPath) + + fun from(request: HermeticRequestJournal.RequestEntry): BaselineRequest = + BaselineRequest(request.method, request.path) } } @@ -649,3 +648,9 @@ private fun JSONObject.optionalString(name: String): String? = } private fun List.nullIfEmpty(): List? = takeIf(List::isNotEmpty) + +private fun QueryMatchMode.toHermetic(): HermeticQueryMatchMode = + when (this) { + QueryMatchMode.Exact -> HermeticQueryMatchMode.Exact + QueryMatchMode.Contains -> HermeticQueryMatchMode.Contains + } diff --git a/build.gradle.kts b/build.gradle.kts index ac0d86f1..2af13d26 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,9 +1,10 @@ // Top-level build file where you can add configuration options common to all sub-projects/modules. plugins { alias(libs.plugins.android.application) apply false + alias(libs.plugins.android.library) apply false alias(libs.plugins.kotlin.compose) apply false alias(libs.plugins.detekt) apply false alias(libs.plugins.kotlin.ksp) apply false alias(libs.plugins.android.test) apply false alias(libs.plugins.androidx.baselineprofile) apply false -} \ No newline at end of file +} diff --git a/docs/testing/player-playback.md b/docs/testing/player-playback.md new file mode 100644 index 00000000..c85371bc --- /dev/null +++ b/docs/testing/player-playback.md @@ -0,0 +1,230 @@ +# Player playback test guide + +This document describes the hermetic test pyramid for the Puber video player. +The suite uses synthetic, committed media only and does not require KinoPub +credentials, authenticated responses, a production backend, or a public +stream. + +## Test layers + +| Layer | Entry point | What it proves | +| --- | --- | --- | +| Fixture integrity | `:player-test-fixtures:test` and its Android test | The same committed bytes, metadata, playlist references, rendition labels, and WebVTT cue are available to JVM and Android tests. | +| Host policy/state | `:app:testDevDebugUnitTest` and `:app:testProdDebugUnitTest`, filtered to `com.kino.puber.ui.feature.player.vm.*` | HLS error policy, subtitle MIME and identity, audio/subtitle preference matching, AC3 fallback state, VM transitions, and generation guards. | +| Real player instrumentation | `PlaybackControllerDeviceTest`, `PlaybackControllerNetworkTracksTest`, and `PlaybackControllerResourcesTest` | The production `PlaybackController` and Media3 player load loopback MP4/HLS, render on a real `PlayerView`, select tracks/cues, recover from programmed faults, and release cleanly. | +| Production-screen instrumentation | `PlayerScreenE2ETest` | The production screen/Koin scope handles real media, D-pad/media/back events, lifecycle progress saves, resume, and series episode identity. | + +The instrumentation tests use a per-test `SimpleCache`, unique scenario +identities, event/latch/player fences instead of `Thread.sleep`, and bounded +failure diagnostics. Teardown waits for zero active server requests, releases +the player and surface, removes only test-owned cache state, and fails on +unknown or external-origin requests. + +## Fixture pack and provenance + +The single source of truth is +`player-test-fixtures/src/main/assets/player-fixtures`. It contains: + +- a four-second H.264/AAC progressive MP4; +- an HLS VOD master with 360p and 720p H.264 variants; +- English (`en`, `English`) and Spanish (`es`, `EspaƱol`) AAC renditions; +- a WebVTT subtitle with a cue from 1,000 ms through 2,000 ms; +- the HLS playlists and committed MPEG-TS segments required by those routes. + +Expected metadata is in +`player-test-fixtures/src/main/assets/player-fixtures/fixture-manifest.properties`. +The complete byte manifest is +`player-test-fixtures/SHA256SUMS` (and the packaged copy under the fixture +asset directory). Generation details and synthetic-input provenance are in +`player-test-fixtures/fixtures-provenance.md`. + +Regeneration is a maintainer-only action. It requires `ffmpeg 9.0.1`, uses +only `lavfi` test-pattern and sine-wave inputs, and is deliberately not part +of Gradle or test execution: + +```sh +FFMPEG_BIN=/path/to/ffmpeg tools/generate-player-test-fixtures.sh --force +(cd player-test-fixtures/src/main/assets/player-fixtures && + shasum -a 256 -c SHA256SUMS) +``` + +The generator refuses another ffmpeg version and refuses output outside the +fixture directory. A normal test run verifies the committed hashes instead of +transcoding media. + +The pack contains no third-party or production media and has no media license +to reproduce. The only external tool assumption is the locally installed +`ffmpeg 9.0.1` generator binary; ffmpeg is not packaged in the application or +test artifacts. + +## Hermetic server and network policy + +`HermeticTestServer` matches typed method/path/query routes independently of +request order. It supports static bytes/text, redirects, byte ranges, response +sequences, delayed responses, truncation, disconnects, and recovery. Its +bounded journal records only sanitized method/path, selected headers, range, +route, outcome, and completion state. + +The app instrumentation flavor pins API and media routes to the server's +`127.0.0.1` origin. `LoopbackNetworkBlocker` rejects every other origin +through the existing PUB-77 fail-closed control and records a normalized +violation. Unknown routes and unexpected egress fail teardown. Authorization +values, credentials, redirect query data, authenticated payloads, broad UI +dumps, and raw logs are not test evidence. + +## Host commands + +Run the deterministic fixture and resolver checks first: + +```sh +./tools/agentw :player-test-fixtures:test +./tools/test-resolve-android-test-apk-pair +``` + +Run the player host suites for both app flavors: + +```sh +./tools/agentw :app:testDevDebugUnitTest \ + --tests 'com.kino.puber.ui.feature.player.vm.*' +./tools/agentw :app:testProdDebugUnitTest \ + --tests 'com.kino.puber.ui.feature.player.vm.*' +``` + +Run compilation checks: + +```sh +./tools/agentw :app:compileDevDebugKotlin +./tools/agentw :app:compileInstrumentationDebugAndroidTestKotlin +``` + +## TV emulator execution + +Use a leased TV emulator only. Discover a running TV emulator, acquire its +exact serial lock, export `ANDROID_SERIAL`, and keep release in a trap: + +```sh +EMULATORS=($( + .kent/adapters/mobile/emulator-resource-lock.sh adb-emulators tv +)) +LOCK_OUTPUT="$( + .kent/adapters/mobile/emulator-resource-lock.sh \ + acquire-any "${EMULATORS[@]}" -- 900 7200 +)" +LOCK_RESOURCE="$(printf '%s\n' "$LOCK_OUTPUT" | sed -n 's/^resource=//p')" +LOCK_TOKEN="$(printf '%s\n' "$LOCK_OUTPUT" | sed -n 's/^token=//p')" +export ANDROID_SERIAL="$LOCK_RESOURCE" +trap '.kent/adapters/mobile/emulator-resource-lock.sh release \ + "$LOCK_RESOURCE" "$LOCK_TOKEN"' EXIT +test -n "$ANDROID_SERIAL" +``` + +If no suitable running emulator is available, stop rather than starting one +implicitly. Physical devices require separate explicit authorization. + +Build a fresh app instrumentation target and Android-test APK with +`--rerun-tasks`; do not use `connected*`, `install*`, or another Gradle task +that implicitly selects a device: + +```sh +BUILD_STARTED_AT="$(date +%s)" +./tools/agentw :app:assembleInstrumentationDebug \ + :app:assembleInstrumentationDebugAndroidTest --rerun-tasks +PAIR_JSON="$( + ./tools/resolve-android-test-apk-pair \ + --pairing-contract app-android-test \ + --target-metadata \ + app/build/outputs/apk/instrumentation/debug/output-metadata.json \ + --test-metadata \ + app/build/outputs/apk/androidTest/instrumentation/debug/output-metadata.json \ + --built-after "$BUILD_STARTED_AT" +)" +APP_APK="$(jq -r '.target.apk_path' <<<"$PAIR_JSON")" +APP_TEST_APK="$(jq -r '.test.apk_path' <<<"$PAIR_JSON")" +APP_PACKAGE="$(jq -r '.target.application_id' <<<"$PAIR_JSON")" +APP_TEST_PACKAGE="$(jq -r '.test.application_id' <<<"$PAIR_JSON")" +.kent/adapters/mobile/android-apk-install-preserve install-preserve \ + --serial "$ANDROID_SERIAL" --package "$APP_PACKAGE" --apk "$APP_APK" +.kent/adapters/mobile/android-apk-install-preserve install-preserve \ + --serial "$ANDROID_SERIAL" --package "$APP_TEST_PACKAGE" --apk "$APP_TEST_APK" +``` + +Run the complete player instrumentation suite with an explicit serial and +runner. During development, use one class filter at a time: + +```sh +adb -s "$ANDROID_SERIAL" shell am instrument -w -r \ + -e package com.kino.puber.ui.feature.player \ + "$APP_TEST_PACKAGE/androidx.test.runner.AndroidJUnitRunner" +``` + +The final acceptance run repeats this command twice from clean +test-owned state. It does not clear app data, uninstall packages, or use +flaky retry as a condition of success. The resolver output is the authority +for APK paths, package IDs, instrumentation target package, runner, and +SHA-256 values. + +The migrated PUB-77 baseline regression uses the separate +`standalone-self-target` resolver contract and is documented with its +explicit build/install/instrumentation commands in the task plan and +`02-server-contract.md`; it must not be paired with the app +`app-android-test` contract. + +## Emulator capabilities and diagnostics + +The mandatory device path is H.264/AAC. A device lacking that capability +produces a concise capability failure and does not silently turn decode +coverage into a pass. HEVC and real AC3 decode diagnostics are intentionally +not part of this fixture pack or acceptance suite; AC3 retry/fallback remains +mandatory in the host state-machine tests. + +There are no assumption-based skips for mandatory scenarios. A capability +report may explain a failed H.264/AAC setup, while the intentionally omitted +HEVC/AC3 decode diagnostics are out of scope rather than a passing skip. + +On failure, diagnostics are bounded to player state, selected formats, +decoder name/counters, relevant Media3 analytics events, capability +information, and a sanitized request-journal tail. Startup, dropped-frame, +and rebuffer measurements are informational and have no absolute emulator +performance threshold. + +## Production artifact exclusion + +The fixture module is test-only. `:app` references it through +`testImplementation` and the `instrumentationImplementation` flavor edge; +`:baselineprofile` is itself a test module. No production +`implementation`, `prodImplementation`, or runtime edge may resolve +`:player-test-fixtures`. + +Run the dependency and packaging checks: + +```sh +./tools/agentw :app:dependencies \ + --configuration prodReleaseRuntimeClasspath +./tools/agentw :app:assembleProdDebug +./tools/agentw :app:assembleProdRelease +./tools/agentw :app:bundleProdRelease +``` + +Inspect only bounded listings and fail if production artifacts contain the +fixture prefix, fixture hashes/provenance, test-control components, or server +packages: + +```sh +PROD_APK=app/build/outputs/apk/prod/release/app-prod-release.apk +PROD_AAB="$(printf '%s\n' app/build/outputs/bundle/prodRelease/*.aab)" +if unzip -l "$PROD_APK" | grep -Eq \ + 'player-fixtures|fixtures-provenance|playertestfixtures|TestControl'; then + echo "test-only player content found in production APK" >&2 + exit 1 +fi +if unzip -l "$PROD_AAB" | grep -Eq \ + 'player-fixtures|fixtures-provenance|playertestfixtures|TestControl'; then + echo "test-only player content found in production AAB" >&2 + exit 1 +fi +``` + +The production runtime dependency report must likewise contain no +`project :player-test-fixtures`. If release signing credentials are absent in +a local worktree, report that package-signing limitation explicitly; never +copy credentials into the worktree or weaken the production exclusion check. diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index e97e5388..5e290143 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -19,7 +19,9 @@ coroutines = "1.10.2" timber = "5.0.1" junit = "4.13.2" junit5 = "5.14.2" +junitVintage = "5.14.2" mockk = "1.14.9" +robolectric = "4.16.1" koin = "4.2.1" security = "1.1.0" voyager = "1.1.0-beta03" @@ -35,6 +37,7 @@ androidxTestRunner = "1.7.0" [plugins] android-application = { id = "com.android.application", version.ref = "agp" } +android-library = { id = "com.android.library", version.ref = "agp" } kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } kotlin-ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" } @@ -114,8 +117,10 @@ media3-datasource-okhttp = { group = "androidx.media3", name = "media3-datasourc junit = { group = "junit", name = "junit", version.ref = "junit" } junit5 = { group = "org.junit.jupiter", name = "junit-jupiter", version.ref = "junit5" } junit5-launcher = { group = "org.junit.platform", name = "junit-platform-launcher" } +junit5-vintage = { group = "org.junit.vintage", name = "junit-vintage-engine", version.ref = "junitVintage" } coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutines" } mockk = { group = "io.mockk", name = "mockk", version.ref = "mockk" } +robolectric = { group = "org.robolectric", name = "robolectric", version.ref = "robolectric" } # Baseline Profile & Benchmark androidx-benchmark-macro-junit4 = { group = "androidx.benchmark", name = "benchmark-macro-junit4", version.ref = "benchmarkMacroJunit4" } diff --git a/player-test-fixtures/SHA256SUMS b/player-test-fixtures/SHA256SUMS new file mode 100644 index 00000000..efedaf33 --- /dev/null +++ b/player-test-fixtures/SHA256SUMS @@ -0,0 +1,20 @@ +# Generated by tools/generate-player-test-fixtures.sh +# Paths are relative to player-test-fixtures/src/main/assets/player-fixtures +be066640856b0bafbe89b98ffb9d8242aef9dd80755e81632845acd2c6859592 fixture-manifest.properties +d0b66ca1cd5cf07f1653e6d186c9aa2bf98c12ae3411684d5a9d4990f0faac24 hls/audio_english_000.ts +f2835f530d2b5a429beca76edaec079e4ab7678523f8f895d97af287efc77ebb hls/audio_english_001.ts +0b4a3635ca144ac737dfbabd915a35906a8198c6d986381ed59ff0075223588a hls/audio_english_002.ts +638546fcf88de892ebf4c35abba3b96a87a1e8288db6e6c8e0213102ba74546b hls/audio_english.m3u8 +f4258109fb94de22cde3e6bcef2d063253d86fd1439c455101257ee2a26295a6 hls/audio_spanish_000.ts +5d031767863b8894f788ea6c55d9fb368b2197634e23c2e1bb6d788eb5279eb0 hls/audio_spanish_001.ts +e0c4b54aa29660c8730a21ffd6725d728ac9299cbfd582e483ad08aded6113b6 hls/audio_spanish_002.ts +57628e73ee5e3813ad203033f8d5d7bc729d32d70bd3a9756c1cfa1adaf7a40d hls/audio_spanish.m3u8 +f49ce7e56a295611d77085ce6dda7e9d4232738d9e69f140f3e72362bc82413a hls/master.m3u8 +2886e10d3a695dbe1fc76c2e5990794602c0c3f75b6f875dd834f0c6fac9e919 hls/video_360_000.ts +584395ec46703e2c377dacaf7c25f4da282037c1097ab6cf500db76ea950858d hls/video_360_001.ts +23b1ecbd66d278f3d75082204ab380e234bf7dd876391b5a5bd84c597c81103d hls/video_360.m3u8 +39b126ca12647e3819b9c353c9a7e0ee97a6f41c270ae8bfd2370bcc690e30ea hls/video_720_000.ts +a625ffd32332483b7b090d7f5c599634c131056fcffbd492a5d2ba7667b24ece hls/video_720_001.ts +db1893295cd255c902a33580a1149779255965ffef2afd66d224e975a77e9cc8 hls/video_720.m3u8 +66e3482994223b65cc915d37218558051216a6668e8b6429102efc35a27ee796 progressive.mp4 +aa39ae5106857d2e539299d0ce5d552ce8f5f96c1594f954c7c8a0eed69729e6 subtitle.vtt diff --git a/player-test-fixtures/build.gradle.kts b/player-test-fixtures/build.gradle.kts new file mode 100644 index 00000000..0c295350 --- /dev/null +++ b/player-test-fixtures/build.gradle.kts @@ -0,0 +1,36 @@ +plugins { + alias(libs.plugins.android.library) +} + +android { + namespace = "com.kino.puber.playertestfixtures" + compileSdk = Versions.CompileSdk + + defaultConfig { + minSdk = Versions.MinSdk + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + } + + sourceSets["main"].assets.srcDir("src/main/assets") + sourceSets["test"].resources.srcDir("src/main/assets") + + compileOptions { + sourceCompatibility = Versions.JavaVersionCompat + targetCompatibility = Versions.JavaVersionCompat + } +} + +kotlin { + jvmToolchain(Versions.JavaVersionCompat.majorVersion.toInt()) +} + +dependencies { + implementation(libs.mockwebserver3) + testImplementation(libs.junit) + androidTestImplementation(libs.androidx.test.ext.junit) + androidTestImplementation(libs.androidx.test.runner) +} + +tasks.withType().configureEach { + classpath += files("src/main/assets") +} diff --git a/player-test-fixtures/fixtures-provenance.md b/player-test-fixtures/fixtures-provenance.md new file mode 100644 index 00000000..e1758080 --- /dev/null +++ b/player-test-fixtures/fixtures-provenance.md @@ -0,0 +1,8 @@ +# Generated by tools/generate-player-test-fixtures.sh + +Tool: ffmpeg 9.0.1 +Inputs: lavfi testsrc2 video pattern and lavfi sine tones at 440 Hz and 660 Hz. +Container: progressive H.264/AAC MP4; HLS MPEG-TS VOD playlists with two video variants and two AAC renditions. +Duration: 4 seconds; segment target: 2 seconds. +The generated bytes are committed. Gradle and tests verify hashes and do not transcode. +Regeneration is a maintainer action and requires the exact ffmpeg version above. diff --git a/player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt b/player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt new file mode 100644 index 00000000..76ddf853 --- /dev/null +++ b/player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt @@ -0,0 +1,27 @@ +package com.kino.puber.playertestfixtures + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class PlayerTestFixturesAndroidTest { + + @Test + fun packagedAndroidAsset_isTheSameCommittedFixture() { + val context = InstrumentationRegistry.getInstrumentation().context + + FixtureId.entries.forEach { fixture -> + assertTrue( + "$fixture is missing or changed in Android assets", + PlayerTestFixtures.verifySha256(fixture, context), + ) + } + assertTrue( + "fixture checksum manifest is missing", + PlayerTestFixtures.committedChecksums(context).isNotEmpty(), + ) + } +} diff --git a/player-test-fixtures/src/main/assets/player-fixtures/SHA256SUMS b/player-test-fixtures/src/main/assets/player-fixtures/SHA256SUMS new file mode 100644 index 00000000..efedaf33 --- /dev/null +++ b/player-test-fixtures/src/main/assets/player-fixtures/SHA256SUMS @@ -0,0 +1,20 @@ +# Generated by tools/generate-player-test-fixtures.sh +# Paths are relative to player-test-fixtures/src/main/assets/player-fixtures +be066640856b0bafbe89b98ffb9d8242aef9dd80755e81632845acd2c6859592 fixture-manifest.properties +d0b66ca1cd5cf07f1653e6d186c9aa2bf98c12ae3411684d5a9d4990f0faac24 hls/audio_english_000.ts +f2835f530d2b5a429beca76edaec079e4ab7678523f8f895d97af287efc77ebb hls/audio_english_001.ts +0b4a3635ca144ac737dfbabd915a35906a8198c6d986381ed59ff0075223588a hls/audio_english_002.ts +638546fcf88de892ebf4c35abba3b96a87a1e8288db6e6c8e0213102ba74546b hls/audio_english.m3u8 +f4258109fb94de22cde3e6bcef2d063253d86fd1439c455101257ee2a26295a6 hls/audio_spanish_000.ts +5d031767863b8894f788ea6c55d9fb368b2197634e23c2e1bb6d788eb5279eb0 hls/audio_spanish_001.ts +e0c4b54aa29660c8730a21ffd6725d728ac9299cbfd582e483ad08aded6113b6 hls/audio_spanish_002.ts +57628e73ee5e3813ad203033f8d5d7bc729d32d70bd3a9756c1cfa1adaf7a40d hls/audio_spanish.m3u8 +f49ce7e56a295611d77085ce6dda7e9d4232738d9e69f140f3e72362bc82413a hls/master.m3u8 +2886e10d3a695dbe1fc76c2e5990794602c0c3f75b6f875dd834f0c6fac9e919 hls/video_360_000.ts +584395ec46703e2c377dacaf7c25f4da282037c1097ab6cf500db76ea950858d hls/video_360_001.ts +23b1ecbd66d278f3d75082204ab380e234bf7dd876391b5a5bd84c597c81103d hls/video_360.m3u8 +39b126ca12647e3819b9c353c9a7e0ee97a6f41c270ae8bfd2370bcc690e30ea hls/video_720_000.ts +a625ffd32332483b7b090d7f5c599634c131056fcffbd492a5d2ba7667b24ece hls/video_720_001.ts +db1893295cd255c902a33580a1149779255965ffef2afd66d224e975a77e9cc8 hls/video_720.m3u8 +66e3482994223b65cc915d37218558051216a6668e8b6429102efc35a27ee796 progressive.mp4 +aa39ae5106857d2e539299d0ce5d552ce8f5f96c1594f954c7c8a0eed69729e6 subtitle.vtt diff --git a/player-test-fixtures/src/main/assets/player-fixtures/fixture-manifest.properties b/player-test-fixtures/src/main/assets/player-fixtures/fixture-manifest.properties new file mode 100644 index 00000000..4e223d4b --- /dev/null +++ b/player-test-fixtures/src/main/assets/player-fixtures/fixture-manifest.properties @@ -0,0 +1,19 @@ +# Generated by tools/generate-player-test-fixtures.sh +fixture.ProgressiveMp4.duration_ms=4000 +fixture.ProgressiveMp4.sha256=66e3482994223b65cc915d37218558051216a6668e8b6429102efc35a27ee796 +fixture.HlsMaster.sha256=f49ce7e56a295611d77085ce6dda7e9d4232738d9e69f140f3e72362bc82413a +fixture.HlsVideo360Playlist.duration_ms=4000 +fixture.HlsVideo360Playlist.sha256=23b1ecbd66d278f3d75082204ab380e234bf7dd876391b5a5bd84c597c81103d +fixture.HlsVideo720Playlist.duration_ms=4000 +fixture.HlsVideo720Playlist.sha256=db1893295cd255c902a33580a1149779255965ffef2afd66d224e975a77e9cc8 +fixture.HlsAudioEnglishPlaylist.duration_ms=4000 +fixture.HlsAudioEnglishPlaylist.language=en +fixture.HlsAudioEnglishPlaylist.label=English +fixture.HlsAudioEnglishPlaylist.sha256=638546fcf88de892ebf4c35abba3b96a87a1e8288db6e6c8e0213102ba74546b +fixture.HlsAudioSpanishPlaylist.duration_ms=4000 +fixture.HlsAudioSpanishPlaylist.language=es +fixture.HlsAudioSpanishPlaylist.label=EspaƱol +fixture.HlsAudioSpanishPlaylist.sha256=57628e73ee5e3813ad203033f8d5d7bc729d32d70bd3a9756c1cfa1adaf7a40d +fixture.SubtitleWebVtt.cue_start_ms=1000 +fixture.SubtitleWebVtt.cue_end_ms=2000 +fixture.SubtitleWebVtt.sha256=aa39ae5106857d2e539299d0ce5d552ce8f5f96c1594f954c7c8a0eed69729e6 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english.m3u8 b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english.m3u8 new file mode 100644 index 00000000..edb5874e --- /dev/null +++ b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english.m3u8 @@ -0,0 +1,12 @@ +#EXTM3U +#EXT-X-VERSION:6 +#EXT-X-TARGETDURATION:2 +#EXT-X-MEDIA-SEQUENCE:0 +#EXT-X-PLAYLIST-TYPE:VOD +#EXTINF:2.005333, +audio_english_000.ts +#EXTINF:2.005333, +audio_english_001.ts +#EXTINF:0.021333, +audio_english_002.ts +#EXT-X-ENDLIST diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english_000.ts b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english_000.ts new file mode 100644 index 0000000000000000000000000000000000000000..c728e799215fa9a920980e0ac5f7bd3d3a3ceb8b GIT binary patch literal 26884 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 Y0O6JmKR&pc_HPphWzQk*-_XPV0ixEz^8f$< literal 0 HcmV?d00001 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english_001.ts b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_english_001.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e73f6fbbdac0168653067b3ae2e23e9eacfe5b6 GIT binary patch literal 26508 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 HL7)Ku#do_z literal 0 HcmV?d00001 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish.m3u8 b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish.m3u8 new file mode 100644 index 00000000..ed3f7e7b --- /dev/null +++ b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish.m3u8 @@ -0,0 +1,12 @@ +#EXTM3U +#EXT-X-VERSION:6 +#EXT-X-TARGETDURATION:2 +#EXT-X-MEDIA-SEQUENCE:0 +#EXT-X-PLAYLIST-TYPE:VOD +#EXTINF:2.005333, +audio_spanish_000.ts +#EXTINF:2.005333, +audio_spanish_001.ts +#EXTINF:0.021333, +audio_spanish_002.ts +#EXT-X-ENDLIST diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_000.ts b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_000.ts new file mode 100644 index 0000000000000000000000000000000000000000..78870a6a81e4b08da1bd6e2ff32e0b0d4d06aab5 GIT binary patch literal 26696 zcmd43bx_=2v+fJQ0>M4F1b2eFLvSa-JxB=d9^Bmt7Thf`xO;%XCAhl{ZgU5I@4NT8 zr}o};>el_^3=}m5Mb+oqtkwOjetID-f`JYtc18sS-30{&h6Y1HKl)+IU_!%7N!i$$ zeMM9=b8xXVF=J(O^%5Tj|KIhJ7J)*Cf~rP&Wru=3gQBm2t^L0X@xP^!R)(;@sm6R| zUxzw_LVNkrkkPsD-~P(~H9wFRg4h_w$1zheDV)0-wu^P=Ozp zpyZ8QOt?NWvoW)=vO&Gkt}b@KX&CqWczmhCjlXkKcHo z$=XPtZ)A{SW-HfJqZzN(y8(b+ znayx*rmM!`vR3dWzsuhw>n6>X@ap+;&XUDhwJI~7qwgA(+uA1@Q3EF5H3^e~w~Z>K zp`kD|zd^oNxmg1^vKj7ii1LZ@@s5Uk_;^F!LEisQAHm+i@s`y8`n1vJw3zv&zF2QH zQ6`c8A^lT+`lr(LlKec`4|%fm=_RGLiv0x*ssV+`TFu& zfUQoI%gx5-6TLXC5A|tdm4Bi!WPdqAR2OPHvQ3SvxM%(4yVc zJsCzt;ug~AVFx}Fu7ayMxF?$>V^z3tpUfMB!w_iR{Ep`|* zO@YC~+)Aax?G%_W$)Lc3NRZ>>e^CyVgxbwhuziS$a} zpD(izb}VWS7Ywf=enom0PaLzXxFn{YOoen84-XevDYX=Yv2n$QKE-jxAx=9L=1;;{ z=0CHdqQA}5CP;k}K+hzZsnbx202zlo_t5qVW4& za$B-XGZFSKO#TQvb!y>Q`JN%aeap^x<&N-3u58W9RLW`%YdETyVK1{Vh=_2=JFR;F7h z?B5ntL~-%m`R$68h`i=E29@;jWj1W0csALwhJrEqGq`yE08gp$`LkahhAjIL>VzxS zB~>shEH7uzg0Em1!j5yg3O@1x-}uG|e&6Pi%1|v8DzI^DeTSb1v4MvMZ{-sXS@Qv=gS}YFOKM>IAY}`cLjP5cU zIN6puUAC3vlX!uRwEhT2&Gnf<*zq!iM3$-e5xJ7BK6%-k=7Z_SXXS}H?ISuR6k1~8 zi(OOgh@s*4crknH6AoC<-4ve}Vom*@XB6!=^NXMiQCuBHG2^y2a*21Lr?n98@=8w4 zEO`(KV?h)O!A!|pEKM{ac_Ot#c{7RE`iBBImJ`AU@9|b&(Is2{T1$^L&zVN{d6xS^#%j>UYLT{cy) ztH^QQ`DhJ(2@nNjo1Ae~I13_$NJ392JC)K9jCxC%ck71^AR2L!A4gVlus;QCO=2dgzc-66QMJuUYC4|4D!K(-O56= z3h$oD)D%T@m(mT;ls0G$hFYkn5D48vVJxTn=9OrGZw(hEP$J=n*d*?_`PWwBF>iB; zR83-|?;OHTz-jk0OLFlesv`8oR|B=6{wkO~Q7O0Gy@@5Kyz;%4;81KkLA!1C$uSr; zJ0Tl9Aqict@hU^Ktd*U5gltI~(K#b#t!>(l?(lQsA(r*am>Cj65g*yT&n14&?=Ze& zvbj!oi7M=Xb?X5xWdTjP*@b0Wf5uA&UKb8o$IF(fi1k1w2+Os%(B*T+4ca`dge)M} zj_1|g&G2uB*}UbMeP6D|N((gB|BAA!1UYm3k)xq2Qi8A(ZUOH)q6HlNT4jgsUDXfD zXl%_^*a!H(?>NivxI39qGxRYxS!q{^O7jZZscUBz>nPl4?$K%J`)31Aqy;o(pS(A~ z_$`Z|1^INvro1;NpJ^1vn~qR z_V{`nize-M3HB_y55i6~vWrtBPj#|3yq*y78Vpj>N2raLMMCsWHCI#1VD7>9))xde zh@yAgk!VV)DTW<$(6AqzMNlg!>8`I0)pkt$OL!P+IQj&)>{hYb;Myp%ReZx-zf?Oj zNMLNCV@#LbZwgZrhwdJ4O!O$YW=FdG5fdd(=uKrD?@IPtO&6j4+&`mZAoneBf{E*{ zVwT274t|_(9~0V8ib>Oa(d|D(q8i$AynQ2*ivB%LVhaZvzJx@!62eX#&+*QQ0xgzP4b4%iGqnk_qPm z*V2%q0rmtcDu^6X{@OsEzZ-dkTtlZm%}@|eboQj87SY9}7Z<%LXZwLlRK}#e&SvjQ7aZaT{Etdv_z|l+4?i{kMO;FL@{DplW%TWq`E2)P9 zyBU_IaUc!Yb1#ZZV}1YbGqK@=hYs{U@dlnE?orI7g^B~epC0>P02lJqmdQ0=iI>wk z(f3%S=Fqq&&tE07@)d+p`g;fHzz`vw5T{Vbf*(|C5DhH+qJeWF|IxtjtX?%R;`dh# zOa@szkU|UzU~p1?_1+SnG-^=E=(F#0pYI*G;dfT+()8>VgGJBDxf=DfnV;=1N7^-l zc4!^w!)Tb$%8Tju$Rze>_ZK~(3McYoUC4$}V`O`YZzK{Y{JtreD8Tpx-ZgVE>~J>l z@1999`TvpqjWZ{ABl{O6TI=I+)RVpx)|d&47TiVDnD(^8Bwtpb!MTp#7bG!8c%M_* zPq~n|qm$&q$m4&A8-Gj6LE5oh#gpT68XvwvoNzQewGX^MT!>7@vF-=VgcJP@(MTA zptQcz*RoKtI77e!CnYsuRH!L_j=QfxbJ%%24;|&uS+`+tqx~y7Yt^EE;e3lpkrKMY z!y9^xzF!}m7=2LPDC>|xrW6M!d%9_`-{2z^HJV+6#e<^_cVx3?XG z6_H{V^Shd(g@CrS=V<7X1*n;kV}(yJoRjd|nhZ$iW5`P|HDdKQ6Q{x|*tNenRmR?j zTN!1Tv2+lm){)=|p?y-U6J(F?mo{$qxCOmotZA8BIgGP_iiNOaeWiicJ#owIgf~uS z?*q;q!kn4QHwlt18yxT4o)A7VXaxk=dE~naiEOgIQ^IE%E2}U#+;&&zpBqXm^Vn$u z^wj)QXQ);mp|-dxl9;g3#NPk`PFBQ-*Y{QX;5mps8*iu%!K|_>+Zo@NQfV&u{G%(U z+DOW-(D)Bs4IKTNLz8*!gPIRsM)|}uL$z}w*U{16-Xe?iQub00lTdL6g%CHVx6*WQ ziL@$vhH6Nke=VmU-9gx~H#B9YthiTDPz%&Q#ztr!=Q!1>?MY9gIhjExlYezp+1j`c zknux`2g1!=^GQfZCqk#j+C@70|Nf{yV?i1Rw?Y;86B%wvOS+kw61bZ)p(vABgGQ^p zrFDWnI??ePZUc|h1snR)MX6EuR3%G*m}MKNX-J<#R8;$9FsN6(D5k#+1V~!A3m%~I zUbAC}+;sIXg$dUPy1_ic&=VL5{l*Y%$p5y-vZexK@i$i!0{a8Y&6$z%2812Q!R}=p zk$_*K|9>0NNlEqE8q!lmflSaDwJ2TC_nwCrbywq-C9 zm{MSpW0I#$0>8i7jNLyo$m^&|X?JwhJZ6~Xx^(^q{c zNjo{k=~k%jg}#&KK2kJMvrO-__ctlY792LO9j`6AkxQ29zC1b^BLIR9wN5cUN`sD(eVrh9T#z@@98e9s(X!2%Fphd8!gI9!e8?lv$*_dM6u3J4&&UT zxbGo;puuXT^bi-V#yfc05)+=e$v3^ZA|7##;H@g>SqSIpaYP`$Dpb*C4EE|5gs|gn zmZrv!Q*YqiAl)nd=ofvY@Vv|?fg|WSEZMU)b?Om~eP1KONQ#$-oVz9tH3*F!CBjko zcG&5A1#LrXY82KnNz@hq#*iErwb%2_a_yTZ=)cTa2bpd0hpNY;wRAn(V^F z4wrAYKm9GKY6^U63m$(G;^oXzo;{^!c!@iHW0Pv>L0U73t>p~XK7#ME{_UPyiEkR^ zvHZXj8vi6V*j#r@yE9hEc*&%}6chg5Iwu_p(#LWFFvrm%5)gKRK1us-4g*$oN@mInCWY}+ zxl+>7FQM?Ipu$LurAGNJvgmikw|=^MmV`HNzmAYKA?tE~fIFdN2t2Mll!P`-Vk2$BM>J*)mZjJg+9D=1x@h#BEE=9Yk66L7t~sjt6yFJaZt7Zlo-WN#a{$Ab zqft)Pgd$AkZSs$5Nsb))hfo1Vf}*J2Ouu^RTi+biurZi(pJ6*=mYTHIvzK*535h18 zDn+_cwulu1TW%oiga_a%@cca(bhsH=@$el`FnXfT;%t6_m|u9LqkgDXZ=`~~x;V^t zoV~LUkp4N`Z(fD?Dbai{a+wRT0eGtE{(3v~Hn!<0-$;Q@55{l+_QU7(A;!~py%y}< z25#G#t6_I@31dDg0g2RZiYx+;-{9@E77Jw-lV}q6<~quLUPm`({XVSSafm9djB+Vo zsdH+|*bsPs;b42P+d;pfs9#Z0OKv_?Y%TUCiQaaofbhaT?=tbkb>s7ap~JIxi`+qt5hIjr8!rtL`HPt(`0hqQK-G4kiw*}-UTosBQwEq=|ngxUY(+tGI+V(XA9MbAVKB2frz_c(b1KVO1Jo|-q3 z>@mp%H!ABs^lH==L|Eg9FX98YJ*#tR~+jz1{zp54V3(RCtt6S zH^o|<`1TN8HQC98FI5u4PK+ak&Gz#En>^gvG)pZ3_~U%*GG)Ff2tkgmC4->z=EKt%Z@dOyKXp9# zcFbvLR6YWVzt2B3akHPZdQ_(|luRC2$}<%GOmfjdOS*h>Jg*617ee@#eoxOgGjxu2 zDD}3kTsl3}N}i+-noA5p+Fws3;c>zUEt0ZK*zy14jb6iY01uWNl+X_u*bVfIBtc`s z+>y>W?tiG++7&5RDG3n}bQ_h^Nh+|V7D|**-Xnh-m!o#YS0K9b1AS3wkrU8h8as>^ zom6Hh72r;g;{5@W0Asd*-UHJi)iHFM_@wZ16}9Ys5f;|E;jEsd6i!xM7Wj-b_^t;xpet(DcANu{J;DidMhZ#*OJE;@%Eo=RK>7wmE z`vA5p4mQ3ditm_EeP(z zncn^-r6MY~26P{rt-t4uv;jH30E|+)N1HK7+|jAT)MHW3IKqK-fUZu$d%lrTsMHEF zzUpr+rIF#R#t3YLw)yDGrX;lNxvKVt2ZzYFWaHkj0w=IVzb-Fiou4KAi$&Do9+5?6 zjN4uCJia(NuAj_84I-9fEOmt&yjGgkmr9e`V4)D409hYId^lTo!)Ywt?c zPiLp|KJq)RkBhY6MR5 zRSHAcF)#<2kX;z#ZDX~ep*uaguG2ZNKKEGC2nVy>Br$Pvk7u8TJ@xOVyQj->7&VK3 zPi%E*B(cqY+?FJ!#Ivw9oQ^o14u|@Uv`K zP}pK`>CXVB0jzW6sgn3s4Y3qI&8-84@ia~!kNaEYJ^{>D*?SmM9b$I#FF%I9O|h%6 z7-oX=T%6P(HKnkI{E`uozAJD(A?I2KileDzRQTAbsc1f^Rs`$h@o>cTKci zI;4A_??)jt#IdJ7j71=m=oU@u{ezpGsJfs;A{%O>-+0f1@fVQ8PRRc=KvKf0v*PtDUE&&r{I3_E}ul*j|nm4 zpYW~o?lw{>HpozfJD&9lJ{6Kiim&pqm?b;2!9V2q4p^r`*s-UnzJFzK(yMRC*w1cE zp**c#gNJ4B>}0Sy3zLVgz}V?|Lv(;&DzAI0&#vcA95TQyK{CFK_$N>}KGY)k!blWK z(1JV7Xd}8L*85K?u}F4{>i#t?4a}*`^tJ>aVXy%Xorlw)ThI*9A*sRBJELMaVx%k{ z(bC~H2IRgk`m<`054Yqp4U+u_8o{=6Rkp-td|{5<1!nEGZfVrANk;V6=IITV#nxeM zmyCL3BX^~)79Sz(IQ;l+uF@VS{S99$XEu(0Q81<^g5=7yB3*>U--$($bw^^U7^@sG zz=C3HG^4XSVm8=ri;(74&WGk{?{T^Kad7$8=zr?Or+d`Y!P-PFFuz%p{uMOXL~lJK z_Xd~o15h{m7tVqGB!m9ET8=48&R}GI1?qrqQU~+~BIj>AvYeoxip#O4^2PfidecHWWLK|=uZbKgT7FWOc&zl_dhHp)mDp8rQ<8neh*PGE19|}Udl92@}-FkKTDQHjsIct0mFf{ zO8#4_uGlUPe~4Pn9gd?E7b}DvPiQEec;kV1Ylc$|zbn1^*f@jqJ(*C}Pijl?@HSs! zLuaH;8K`5WCDi*f+hz$PP)d6-*RaJ|N?1}gX^aE9o9fcv=skQaS7l`tX9Kr>C)5LW zpkk2t*wWFju;hr_9pm&N#r6%w?_`fgYR=!E-|6PON_6t<*Ypvo%@iYUI>7@84Pl5( zp27jx7X16(_ue<#RtS$_)Ltd|Y1op#w;z6wO1^g5=>l8X8vwpme~JJ?*zx7=c-lm@ zF3pSnvOF}}%vJ5<05eM5RrMSkS4@p4>{dS;N#K)Dq9QXQ%s5FLWj*bDtDHBnZz3$u zIKigoc~S{a&=E*nzeG+Tjfv}Y!YDK3$H-H9Pb|{V$$u_DRdQJL6QNf7;oz~UlX>p* z+bQl7_euj~P!*?s>}Ioo&ilA@u7DC}nw^d~Ng<9yMR< zOTo&AJsZzKx>c*!vRojbUN|}R)*{G+u)ilIh1X)1P4TGMafv;(f89Z(keIwQ#M~rt zd&Gf2CuL$31jRgH5lQn6_<`g_aWoS3s4(v`Hhbrfjtmg}+>SH@IuYMrWK+CpJdD4n zeL50WH}Z+AI}7dbZ#i*ai#CgVpO?bsLRTi0o3mW!@P$&hOYGZFb$(1sB44l&)>c?n4*I9-$i!svNPxbbC+OM$xA#hpA;q;kJ%gdB!-|Il)dx(e#iVx)?>j1v<<6Mf7Jrh z1^#(5ES<<^G6EuIs0(8#qyHw#UuhKxJ7FBzgzPHL9Lp+qW|Q}1hs4dbu*781NcKg_ z^Et>-SfSie2x_@|c2c1rJ>G!Ob6w{;aj)haD)~-cm0@XpSirsIncSCBfm*>=1UwXJ6^mgNK;S}P4Z37-ew1H z>EYYHBZA11>9?Qnt6SE$ou)Uf1k}buPP08SW|t^4nf@pT=k5cpGW?vX>hOov&^?r| z-oqJIK%@FA9C&e6!dkRRl@rI3k#BIJqR}%y;a5S}iB&!}6RZej1~f{rdSLj>-k+pX z-)KG1L;)={25I%UB_0)vMBOJwVKwf5A&c7r9DfwciPH0sNbLM^zR&lP1tED`-V|F2 zn<0ug{!?y*U;U}ra1Jc7bx3ZtA|{CH2URtKcOQLko}NjbXJ$U=U>AGY;<44F8L?{? zS(*OA4sn)g{DQK@MR7Vsp6YEavuo%*kXj%0TVS`yB9g3r-1M?gvYj4th(|7yA$?Oj zP^EVW!Y)McU-sW$Tk<`52CI9KFy_F}3(6c8Gv(xz49P_l^>UiTHFQ*Ny4g&=sLxrq zfE$GA37&KJNFK#;ieo$#exA$GA4>+-BH28eKSAeJWvfEkbKYJ0MN1!9ekogj6fbqT zCEosZKgfMN(ZkArBHqNj7lEFI_an9>3h0>t=8hLQpcwZy5S3oFif0sD%7W8^!H`i$=x5OYmueYQczGrTG;%;XzKrTR8<8aq!Ifdv6UMW-%(ZaB0n#2_;NkR&PVnwUhJxsu`Yn(CA?*5g3Of5p7u7 z^n+wLCa}{NPQ%NAB_l4Ejc*6q?b`Rpx?$!5iLqQ=6S-yh_+`6?9m&V1Rh4+;&J*`{ z{F3&2q$97oA?%nckQD9CpH#rYq6B}+B!Am-%Ucx?5T3&W%McL9;>{xn`oJ4sXZ24U zRv)2uAVteX5)*;ke@~r{1~;fLPZ{zCkLPgrIs4J~9-PtIl;y}%mL!XIl)sSVvV+1N zZ)J}{BkXRck6d-ZmPA5PW<6+V>7Xuko|Mnb;<{3z|B+%YNHsFy3 zv%9CRR;hITTy))YbIqR%MoOXTfbTDDC}a_9p)FG{FwfNG7NDH_j@)#^y=`2D9g2G* zOd4wD3~3$>!j7$LMWnxVTXVvE3n3f^nnQ7o-32;Y#{Fuiqux>T0cHX^NBC0_R4j^^gz3kyH(sIiTD}C&oBcGI%PE@g5SM}V zWP&Of(z$bQWiYhrAndr813ZwkAO&NXhxM2H=Wr%WR`N6;@mKfWBCsRMj9%vE?oE8O z9C^~n>vNL}|J$qjfB95G!aDy)K2?(mV<~C;CeahXo{6$F-$s=_z4lJK4zK&`bOwhC z)%zb5;kXRqDM@4RdFX|$65tPb9z;b@pw{*aX;~Rp_IlbREPk-N8h5G6@)V@Kyfy ztxDQfJ~f~=uQ*KK*+d<9b-`&N!GLJCNDrN8xLgN|X+B)r@aOC&SMd15gLTHAeUBy6 zk>y$0X5Tao`5L$Yj^9-B>+*f6YQ_+Dd?by|ZHH0MZ?@ea=XBvd7u1HG<)0aDDGAGg z^KQN?CWW8KcnGVnI}CnzOo1jrbIuEu<5^Uu5m!53;e(OT-@mP2upnkkyvMkLS$^Xu zK~8-Ff5KwH5eikp1f}PlkAZ=)4Q2j;h+=-NzD^%0)(gOF#Q0&)ka?q7aDt5_L=ZmQ zL82hkU2Kk`gZG^W_jOK_zw~loEcubV0El4`m_B7Oy3dTywrhN0Ij%)`r})dprGiu- z$qmB(egY28x`hG{Lp4j7;Ou8_<#>)&byX;#3^2wT^$&I#UHw-l75Tknt|8zuT=3nBmM3@s zqGrHKZKXwxVVv&JL+b52Iu3w-4Oox@m3$IAMueM<-CL(ymI;GXxfmUt+3P5SFAej_ zy~%?=7~*J0I``hI)6!(t#lOLMiwjrYfAG@~!cGvP#ldIFT>s9-TQ;5nsV=rjR4e$R z^9WUWCMt)GA&{9C$=xCvf9!rJ_(yZUgY3DG+n67-PS7d=jrt9>nUO9vmq@E6sU!|Q zb{za8u@@%5Gz90^EE9VZSWHW})c)N8ZU)yzuf+N$4w6JUH!Zm6@#zUOY6xpAk0hNi zm)Gt}Roj!&bQ^vZucgXD46OKnDoMwSqJy|L5-egH5Cf}J0jc!r6l{A6?s$AK)wimO zg0K@Vo0g`;WCnpa(=@8@%)-rERsSmo%U6js{!?f!>A}M!yXSrMc1u5!uz86XI;Sg(B-};N$_i%+b7r`Aa|57aAX$tQQ2Xm9(j1@@T% zvf=80*E0b4CAmU^0V%7ZP8OLSIFwY@m*9sv@c0}kQHeLb?fi3UDRZ{7?m=y%$!NMW z|J7!8zdrau6lK?+(uL+Kibhe&JIyi9`i;m6lf)-p3xR@P4aa@V)=t%|d13L&_)_b( zMsCJ9Z}E*f8DM?_6lD35jK$uuawqa<-L}z&KrJx#pp|)jL;Yms1z{JY`|maIs}TOr zFK^sFS_I^=UH?RW7VP-3+q3*_ywb|DE;>7Q8Q;#tt9j|(m4bwk}OVxrPs0ZS1;Yo^cJQc4ZNSV1a3YXAVx3U%5yc;UjK^tX}5y9jK9@rzUtcD ze!`rBL|!hIlGAS;zL%Wg!h#T=qa_x_o1wD6tsqMz_fF-9o@!9K7DNLJL1s{(@&7%8 zg8!<4Q50V_FgfWzDo(~4XDH9eLOmS^H*7=G1N;CU2ipo-N9!4s&03X~SjMbaRi-%= zzyCr<5l{8TfC7&;bVWSYuVXIPr?6`6{M2YAUVS>kG7df<`ff|;Pxm_tAJz#TLe@bZ z)By8~+hEZXmUJN69v<5r0jsZqV((Z`rj5vP)RGoB?~RQp+_)I8Ak>;MW}Hpb?8g|Yq?Vp=E_>R6%PZ|#oGwQ$a}(}dA8kwK8V0+q2s(=u zZ>ab?3*Mo_vOJyGBfFia|qhFRB5oF0hCfn>rQP3nsfvJ!a734hd3;6qVwxb9q-NLPO5Hw4X!-Xx~Tdxp=4`D~Y(^qKUNoG)&MQNhs z?T2Ujgb{;&X&WpW;&#Zx(6cqb-~EIfyhL?Q)JWLwM+Y{vyIsz(`Z)RM^`!Np^i+_v1mT*$ve~dkk4-w+fKp^Dkg9B;Y zP88R(Y~I{lKS9_rI-YNYAHf~{4SL#FTB9N}S`{Z&CUF@xHpai+DM%{4Bf57oiS7QS z7xRaNJEtuu-M0e7&yTaP5Ns0ZwN!I5fL76{zS#5$Rih9rdtgPT3xRtFp2&gyqyfFhp=Nd;hwRyM$atH zd=IfjbqTELnlARuKX05Fu6)czN*;Vwt1lsV>EHiFK@%5+oL|&m#szYLc}2V6qi5d- z-?_5z)r3ea`qiOL8iK{^b3-djE2rjk?bz}arB!RAi}p*mt?mLtPDKa`Q#(x}E^+u_`6M;2p54=P!m+zF236ANTIU-aFvxDXd+c;X$6Tf7xunDXPe% zOmX0Q(fv3=5?5h)0SG%*4y+{V52!E#IAJ_lN)AkBl;Mx>#Gqj>yWEOJ>T4P)p)`#f z9o1??4APPP2P2$G9*UCoX2YUX%ztl20~kmC6r~iyVi!k<&k6Mjh?kbkkCFy@P;Uo0 zvEeDAWd~R#r*w6`mfMb(Vv`E#wPl68m{;Y*6myW-y_!RC_T7DR*{D?dGDMRInX{Wj z-DuH%995s>tVFd*;u9Z#q`~7ylnI5fV?!LQ^q?kuD_q$5 z-(rY;r$yw+tUq-9RzaHg5=H+QSX*D)`fl!?h3W%c=WVz_|`SDy?iV39@rd?@9hVzJN(V|(>s za}u_HT-NK{Th(iX`rULf?9)97eiN z8FDcbJRlWaJ?X#?VaFST0d-&UrAq4<-qNVZx+L?)ZGK(-Ql8KG0XhzZr5GTPi}ndK z2BQZp-#ZQUv+8u7lApZ^o0A}}osvl#NF%M7?jSVP5nwb%mOpMXEsn*B058Tb>W2Hn zU4yb&rkJSHsz|V#qLVpS2dQ7yQ`t*F&`F4ddGc$)`1hB6KmpkYuf0YT>Ymrz5S*xS z;D8FWSCGdcL^BiKvq{yo_hVRCxdOczf{ShzHsqxtbMev6Vs%%38v`x-*0? zm_7lIe=agbU)tz=bONF7M$C~MZ7Yv}yfsx>1Wg-d=d;_dQmcsb#m|a4{0G)7%0Pbs zy5s!|)k&D9AGXYdqXiK5_fVmTaRK(|dsfMS(t_1O@qA``_F^XmosaI$4x&uVuOn6e zSXz)-Z^2-=mmJB#Bo-oeeclgN0@oaat8NdYhT|8@l0N-zcP~qzZffliN#X$E%BGou z=rtnp-}`bZ9>W_D*y>HJwA56j9kTva!TT`7uFB-lOR%;s$pwqSAIYsz{Y@g^hq96j zDR8FC&P6W%Q@{9vk-t?W9yw*~OymUu3SMCSO`6HJ2*OxWWW*%5+h05PT^e z?t)6TFruR=mL~CR;w#oCASgS#kanEI5Z2%=1Ozm}u%*ALL|`I?DF{2J%EM$wRhA%i zE(>A8K2-jS^}DMPZY43;-y@ALB%K7CkFS-C6P6ki3PWTGIz6JK=B=``sqLV!KHIpi z@{{9c<6aYJ%Fa0`J_dKi=LhSnd)3l3BaS(VRu|9}J)C*`K88!!0K!g0u>HG%BdTuG z$Ww>9VztXU5%Zse3nZ07@<*%(S8$K`e|T9YS`WTYkh!y|#|QVTU3VW#*KnWVRm4{7 zh`f@NKsj6aRiBOkkMUxfIkHj52}ppfR*0Zcbyw6~S?d z_k^c3rCbMVzD~FeZH=hFhh>XuLu)c3WmlE#~ zA&7`Jql6l3=-QTTZ2i1P7d1uuOM6o<5h6nNKVRfZQJ3I~$RI|F-FF+?75U%HvkDj9 z>Rv~x?rD;GNol#3cwAWsJI3pghTPz_y4i(GpuM&fAV-=IsgwV>?NzIuHftGwQ00*0 z%;vVEx~8K!qV{{~*ovp9pr#Ix242la0tb0ERgx6WaZg7SHXW)J7*A1QIbfGb(ka;s zI3nU+Hje&9r&(12`eH3a@(NViGX+m>Fx2jlP@OPopr2xhkT_K%1(K2xqfz6PRUikf zL_?!{=xN|Ur?rSUCioFo(+8-LmPdP3#k9};u<#*Re_1n_M0iUdt!~7-8=ZbCp4IQ4 z`Yi>0`HS~#ucf=Q(o3^T3`r>(-LvMz7{;PvIpR5dHH%T4uV7NoY|UJ6s)fCAf#=t--x| z_og4wDlCbP&;TIZxQ3$4%VUf{+_a;t#KFcsu`e`;jxW9kmZPqcHRnDF?gvxfkzk26V6z5G4k_F zeb@DfpdiatVS@WM&~}CE63&5l5BohQd>sd0k*)uVws3iX&oa?RnD#9J!bx(}RE0Z> zip?gf=Qhd%tzbie&@sC$fUn@3c(dLkaal^OH5x-}Yk@Uuu`5xQ)fD^wKW_U==Mr+< z{iFSl{RLsiPV~U}_hl}}0dUN{m%T!6pAP#B^#SEUX<8&uKG8@|;UnhIu;tVpC&3X3 z&$$?sK9%Vcf2p%ZLSyaedy`a-i~7m>WPYPLN4wNE2~&^gHjFiCUjIeQRW?n3`ZD0h zHNGAxI@xnj#G~=4^|(0#uU(K+l8LUt#zpdO^lyI4+sp!TZ(t=BF)i6a52%i!AF&iW zJkZd|o&#|~g)fZSw1TFe7K=Ul8x?iQm@Vsdkmnv zSnMj$j9l$y@w&R~o?N|%)%1`@pT?O{X#!njiB;D?92;2}^G#kG_4|P>>vF*||C}Tt zsR!bO&6*2fiS0lPFxLNc!UBB_#=#+AVbF2EZN))~GPpE>sbLpK%7)g&IPsH2J^|6o zOf7D+t~k8y9`j+Jl{d_#gS^*WR5t70tfAGyb&xQD$Lyl)MMrD5@j47|_hR=g-kQQ< zEu4Y_WvNc%q~0g%O=SsTwIVI;d3~JgB%J2&DJZn7!|qKt&H%S1q`7vb#*`4k{qIpO zDgs9?%{z}Y<7iew;Pg6s8m-Q9#v*p2C&edyy>ntTUvgQjG0dA`M{~cVgI6o;zqi5Y zG3CNg>Bu4Mcz=>Iv|hv!8Dw+4`d|_y;xG`cD9eNt136C@J2CI?9)p#hg`a#!S9He( z$LP;WWS*C?&Bip~)6%URXb8vO&*S=)qjS|bczzR{J-09Tc<|k-(ww5= zt|p0&dJnn^Ga9;V4X2s}utu*sD)1Yg2H#7lwR!{f8j*>rnFNYTcIQ1o*8J!3-qkgtDLtQVI_|TPqMkquEIqMjmpHF%N@62mZ61A^samfES<;9h1zC zs2?7RMMS`3+LAxTeL`_SUUNs0GO?9wOyVGYA3?*tAeQJ12QkMPI)oK}D` z#fB4t`N^s8cooT2&Xnmj9>m~Rk1W!S38g33uh{8;3BpbQSsABgKG`oOh2EE~NVZyCxM z=ve3+Arn++G8B3Wao$dpC2DWi4TG_*umzWKf!nOn&aa&&ru@c&N1*FR#SOjCo<+eW zO8T`;Ma6x4jwWviJE2ZF|9Tgo^772N>3E$~Vu8NLZf%p6s$2J`U82JmB;D6aL-v{y zAc~kV91(I!)`Aams+3qc?Jxj)j)Sus8=7WxN8*i3HDuuRJ}K@scM0?>Fnv-Z*B^ef zb0J;H^R7+nLFhx&AD)!K^JMR$x?{o6%|a7)H99x8v`_`z*+ts;v|3Jvv2ua<$haWJ z$~6nPweLW`OVQsViU}WB@`Jwx4!Z>ju)j$|XNxoF!MSO>9f7b5$o&7MfqyO7>ze?_ z(%mDYf-P&SD-P$rojpAVd zL<0-H^sv9m|7#AL?^Oe%g}rLv4;}xq-~>>A>`u~NGB0Uef)6{MeGO(0vp$wr((jzo zY5hr}gPuKYfyG5mVpku-{_`b>i>yEwRf}=1p+8m6fMNbi5mL8h@pb8iXLZ_NEMoRg z(4EU6zxSt?MJ?ko#Am zi(xyF75J^ikhqgXOuUQpQk|LJbj4Vs8qmD_U1+Faw}OIT^uM`oygQ#P6wLdz<>;cP z`8bw!ZMXTNelOO0U1$yh)926gE(w6U?P(UPq^;2%gdn4H9-SL*acld&?`t_AqXlsr zd#(mWS8nJ?1jiL(o4ky-Pd*1)(^SoZ?poUxy`$1dJh({79o$E6d{pbs^ z*&zSJ1)6&Xk)9h$muPt zs~Ccvur{`u%*Jfw120X0_~DD<3>5`iJ63t9v!i&S*r7wQVkuG5Q z{(m@Y!KgFE& zUzG2+?vV}|TDqj9k&qfdN+qOABqcsd4mospH!?KRZ2$t&Al)h5-7P4ypFus_@7`zc z6F;0Y^AB9}yyjW=y4U-<){7P;F>F8IhTioJI(=31@#*QwbAp!iS&BNP|uXvBM zeXIk}Dt4C1rQ<5mq+IPmA-Lh5nk5#Wh$OG5#|vTvSSMUMAMeNk+6kugL<@|0t5*-E zF}AEGBWAiyvI!Hd-)h@}OWFNB8YtJa%i<`LDEIk-FDYVp9yRu5me?poz1*u9#cdEL zIJ3!<-+M*PWj_)fVQ4ZCw-Zp9r*J#^M>N5kw_uH?0~t7;m8dDgrE(pJPT&`|@XUoB z)RVgL1I6SN<=rCt61&8D+9z+uHhMtbK?FPZnO0a*oN|ob-(UdCc zc*o5Ip`J0_2*T}Tv|jn!(FKA!0|9PFpfbSuPOw zF|^KrS;AFNor?{nb~+TBktM)kEkrMe!4+>R`RbHgM-`3{?G8GP%g=qO7$OJ~-H5s7 z!{i9P?3hZzt?!?}4PJd@%N=4$v;4gb2`=dz-L>KGGtO>*%;57;ieWlRnM^c3y)y

_hJm->^I+6B7vqK3HV206uzF`v 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 Yd3u$_ZF+@ota^{AG&yfKCQAGK8?Zf9X8-^I literal 0 HcmV?d00001 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_001.ts b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_001.ts new file mode 100644 index 0000000000000000000000000000000000000000..0fda65ddfe007ae6d3dae314671dd72c1c7c7b1e GIT binary patch literal 26508 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 literal 0 HcmV?d00001 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_002.ts b/player-test-fixtures/src/main/assets/player-fixtures/hls/audio_spanish_002.ts new file mode 100644 index 0000000000000000000000000000000000000000..f429c1c375439ac2d97f276e8a02dfde26c9dccb GIT binary patch literal 940 zcmZ>F5ENo?`k>0dc#whNKjVJ}#y<@r9zu+4Zf>~+sp*`-sYPX($*Bg0~;pm4-8rxSvCzWC*pLCdjQbwOdEv2Zhy$|fq@@HY@2=HCQdDbM#9~Z z!IV9Kf!T(qj)8%J@c_fmh6Ywe2H87_|3CUT$l3p4cx1NLBAZf#n-I_qfC z#^B4B&(1c>?X!4v=FFM1&pub~xtDKd@wg9+x{ZzDY@i5`iyI&*+-&U5$Y7SiK&PO@ M?Iu!WYM`J10BGaEZU6uP literal 0 HcmV?d00001 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/master.m3u8 b/player-test-fixtures/src/main/assets/player-fixtures/hls/master.m3u8 new file mode 100644 index 00000000..17c9e02e --- /dev/null +++ b/player-test-fixtures/src/main/assets/player-fixtures/hls/master.m3u8 @@ -0,0 +1,9 @@ +#EXTM3U +#EXT-X-VERSION:3 +#EXT-X-INDEPENDENT-SEGMENTS +#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="English",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,URI="audio_english.m3u8" +#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="EspaƱol",LANGUAGE="es",DEFAULT=NO,AUTOSELECT=YES,URI="audio_spanish.m3u8" +#EXT-X-STREAM-INF:BANDWIDTH=800000,RESOLUTION=640x360,CODECS="avc1.42c01e,mp4a.40.2",AUDIO="audio" +video_360.m3u8 +#EXT-X-STREAM-INF:BANDWIDTH=1500000,RESOLUTION=1280x720,CODECS="avc1.42c01e,mp4a.40.2",AUDIO="audio" +video_720.m3u8 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/video_360.m3u8 b/player-test-fixtures/src/main/assets/player-fixtures/hls/video_360.m3u8 new file mode 100644 index 00000000..1fb7e8b2 --- /dev/null +++ b/player-test-fixtures/src/main/assets/player-fixtures/hls/video_360.m3u8 @@ -0,0 +1,11 @@ +#EXTM3U +#EXT-X-VERSION:6 +#EXT-X-TARGETDURATION:2 +#EXT-X-MEDIA-SEQUENCE:0 +#EXT-X-PLAYLIST-TYPE:VOD +#EXT-X-INDEPENDENT-SEGMENTS +#EXTINF:2.000000, +video_360_000.ts +#EXTINF:2.000000, +video_360_001.ts +#EXT-X-ENDLIST diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/video_360_000.ts b/player-test-fixtures/src/main/assets/player-fixtures/hls/video_360_000.ts new file mode 100644 index 0000000000000000000000000000000000000000..ecf62409f24bc5f0ce6b90efb8cbbb5cc58e0f84 GIT binary patch literal 178412 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

u&cBW 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

KOg*!D6tC{83X3;B0s$R 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 literal 0 HcmV?d00001 diff --git a/player-test-fixtures/src/main/assets/player-fixtures/hls/video_360_001.ts b/player-test-fixtures/src/main/assets/player-fixtures/hls/video_360_001.ts new file mode 100644 index 0000000000000000000000000000000000000000..65575b4a7a9c822613bd63fbfb89098a9330ecc3 GIT binary patch literal 195520 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 z∈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±P$$#w$egRhWxTWxkcZT17 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

p53mOtfv^k9g} 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 z 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�pP~^w|bYX)4(rL)Rqg4Rp1(7;CCttE=(T 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Ð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

0#QAepE_4 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

X^#B#W?w4! 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

n~;%vct(WmB2ZRUf_Pk<83zuB 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�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 z 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

    6oEe}~y&u9Q2o$@w0>A?NBfn&vwHc$QDHE0m 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

    ?eqN10D`ReA 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 00:00:02.000 +Synthetic player fixture cue diff --git a/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt new file mode 100644 index 00000000..a59c9ec2 --- /dev/null +++ b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt @@ -0,0 +1,118 @@ +package com.kino.puber.playertestfixtures + +import android.content.Context +import java.io.InputStream +import java.io.InputStreamReader +import java.security.MessageDigest +import java.nio.charset.StandardCharsets +import java.util.Properties + +/** + * The single source of truth for the deterministic media pack used by player + * host and instrumentation tests. + * + * The files are packaged as Android assets and JVM resources from the same + * directory. Production modules do not depend on this test-only library. + */ +object PlayerTestFixtures { + + private const val ROOT = "player-fixtures" + private const val MANIFEST = "$ROOT/fixture-manifest.properties" + private const val SHA256SUMS = "$ROOT/SHA256SUMS" + + val catalog: FixtureCatalog by lazy { FixtureCatalog(loadProperties()) } + + fun catalog(context: Context): FixtureCatalog = + FixtureCatalog(loadProperties(context)) + + fun open(fixture: FixtureId, context: Context? = null): InputStream { + return openPath(fixture.path, context) + } + + fun openPath(path: String, context: Context? = null): InputStream { + require(path.isRelativePath()) { "Fixture path must be relative: $path" } + val resourcePath = "$ROOT/$path" + return context?.assets?.open(resourcePath) + ?: checkNotNull(javaClass.classLoader?.getResourceAsStream(resourcePath)) { + "Fixture resource is not available: $resourcePath" + } + } + + fun readBytes(fixture: FixtureId, context: Context? = null): ByteArray = + open(fixture, context).use(InputStream::readBytes) + + fun verifySha256(fixture: FixtureId, context: Context? = null): Boolean { + val expected = (context?.let(::catalog) ?: catalog).metadata(fixture).sha256 + val actual = MessageDigest.getInstance("SHA-256") + .digest(readBytes(fixture, context)) + .toHex() + return actual == expected + } + + fun committedChecksums(context: Context? = null): Map = + openPath(SHA256SUMS.removePrefix("$ROOT/"), context).bufferedReader().useLines { lines -> + lines + .filter { it.isNotBlank() && !it.startsWith("#") } + .associate { line -> + val (hash, path) = line.split(Regex("\\s+"), limit = 2) + path to hash + } + } + + private fun loadProperties(context: Context? = null): Properties = + openPath(MANIFEST.removePrefix("$ROOT/"), context).use { stream -> + Properties().apply { + load(InputStreamReader(stream, StandardCharsets.UTF_8)) + } + } + + private fun ByteArray.toHex(): String = + joinToString("") { byte -> "%02x".format(byte) } + + private fun String.isRelativePath(): Boolean = + isNotBlank() && !startsWith('/') && !contains('\n') && !contains('\r') && + split('/').none { it == ".." || it.isBlank() } +} + +enum class FixtureId( + val path: String, +) { + ProgressiveMp4("progressive.mp4"), + HlsMaster("hls/master.m3u8"), + HlsVideo360Playlist("hls/video_360.m3u8"), + HlsVideo720Playlist("hls/video_720.m3u8"), + HlsAudioEnglishPlaylist("hls/audio_english.m3u8"), + HlsAudioSpanishPlaylist("hls/audio_spanish.m3u8"), + SubtitleWebVtt("subtitle.vtt"), +} + +data class FixtureMetadata( + val id: FixtureId, + val durationMs: Long?, + val language: String?, + val label: String?, + val cueStartMs: Long?, + val cueEndMs: Long?, + val sha256: String, +) + +class FixtureCatalog internal constructor( + private val properties: Properties, +) { + val all: List = FixtureId.entries.map(::metadata) + + fun metadata(id: FixtureId): FixtureMetadata { + val prefix = "fixture.${id.name}" + return FixtureMetadata( + id = id, + durationMs = properties.getProperty("$prefix.duration_ms")?.toLongOrNull(), + language = properties.getProperty("$prefix.language"), + label = properties.getProperty("$prefix.label"), + cueStartMs = properties.getProperty("$prefix.cue_start_ms")?.toLongOrNull(), + cueEndMs = properties.getProperty("$prefix.cue_end_ms")?.toLongOrNull(), + sha256 = checkNotNull(properties.getProperty("$prefix.sha256")) { + "Missing SHA-256 for ${id.name}" + }, + ) + } +} diff --git a/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkBlocker.kt b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkBlocker.kt new file mode 100644 index 00000000..4f6c2d43 --- /dev/null +++ b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkBlocker.kt @@ -0,0 +1,59 @@ +package com.kino.puber.playertestfixtures.network + +import android.content.Context +import java.net.InetSocketAddress +import java.net.Proxy +import java.net.ProxySelector +import java.net.SocketAddress +import java.net.URI + +object LoopbackNetworkBlocker { + private var installedSelector: BlockingProxySelector? = null + + @Synchronized + fun install(context: Context, allowedOrigin: String) { + val normalizedOrigin = allowedOrigin.removeSuffix("/").lowercase() + if (installedSelector?.allowedOrigin == normalizedOrigin) return + val selector = BlockingProxySelector( + allowedOrigin = normalizedOrigin, + journal = LoopbackNetworkJournal(context.applicationContext), + ) + ProxySelector.setDefault(selector) + installedSelector = selector + } + + private class BlockingProxySelector( + val allowedOrigin: String, + private val journal: LoopbackNetworkJournal, + ) : ProxySelector() { + override fun select(uri: URI): List { + requireNotNull(uri) { "URI must not be null" } + return if (origin(uri) == allowedOrigin) { + listOf(Proxy.NO_PROXY) + } else { + journal.record(uri) + listOf(DENY_PROXY) + } + } + + override fun connectFailed(uri: URI, sa: SocketAddress?, ioe: java.io.IOException) { + if (origin(uri) != allowedOrigin) journal.record(uri) + } + + private fun origin(uri: URI): String { + val scheme = uri.scheme.orEmpty().lowercase() + val host = uri.host.orEmpty().lowercase() + val port = uri.port.takeIf { it >= 0 } ?: when (scheme) { + "http" -> 80 + "https" -> 443 + else -> -1 + } + return "$scheme://$host:$port" + } + } + + private val DENY_PROXY = Proxy( + Proxy.Type.HTTP, + InetSocketAddress.createUnresolved("127.0.0.1", 9), + ) +} diff --git a/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkJournal.kt b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkJournal.kt new file mode 100644 index 00000000..7d0310ba --- /dev/null +++ b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/network/LoopbackNetworkJournal.kt @@ -0,0 +1,75 @@ +package com.kino.puber.playertestfixtures.network + +import android.content.Context +import java.io.File +import java.io.RandomAccessFile +import java.net.URI +import java.nio.charset.StandardCharsets + +class LoopbackNetworkJournal(context: Context) { + private val directory = File(context.noBackupFilesDir, DIRECTORY) + private val journalFile = File(directory, JOURNAL_FILE) + private val lockFile = File(directory, LOCK_FILE) + + init { + check(directory.isDirectory || directory.mkdirs()) { + "Failed to create loopback network journal directory" + } + } + + fun record(uri: URI) = withFileLock { + val violation = normalize(uri) + val current = readEntries() + if (violation !in current) writeEntries((current + violation).takeLast(MAX_ENTRIES)) + } + + fun snapshot(): List = withFileLock(::readEntries) + + fun clear() = withFileLock { writeEntries(emptyList()) } + + private fun readEntries(): List { + if (!journalFile.isFile) return emptyList() + return journalFile.readLines(StandardCharsets.UTF_8) + .filter(String::isNotBlank) + .takeLast(MAX_ENTRIES) + } + + private fun writeEntries(entries: List) { + val payload = entries.joinToString("\n").toByteArray(StandardCharsets.UTF_8) + RandomAccessFile(journalFile, "rw").use { file -> + file.setLength(0) + file.write(payload) + file.fd.sync() + } + } + + private fun normalize(uri: URI): String { + val scheme = uri.scheme.orEmpty().lowercase() + val host = uri.host.orEmpty().lowercase() + val port = uri.port.takeIf { it >= 0 } ?: when (scheme) { + "http" -> 80 + "https" -> 443 + else -> -1 + } + val path = uri.rawPath.orEmpty().ifBlank { "/" } + .replace('\n', '_') + .replace('\r', '_') + return "$scheme://$host:$port$path".take(MAX_ENTRY_LENGTH) + } + + private inline fun withFileLock(block: () -> T): T = + synchronized(PROCESS_LOCK) { + RandomAccessFile(lockFile, "rw").use { access -> + access.channel.lock().use { block() } + } + } + + private companion object { + const val DIRECTORY = "player_network_journal" + const val JOURNAL_FILE = "violations" + const val LOCK_FILE = "journal.lock" + const val MAX_ENTRIES = 64 + const val MAX_ENTRY_LENGTH = 512 + val PROCESS_LOCK = Any() + } +} diff --git a/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticRequestJournal.kt b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticRequestJournal.kt new file mode 100644 index 00000000..f190f3b1 --- /dev/null +++ b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticRequestJournal.kt @@ -0,0 +1,120 @@ +package com.kino.puber.playertestfixtures.server + +import java.util.concurrent.atomic.AtomicLong +import mockwebserver3.RecordedRequest + +/** + * Bounded request evidence. Only transport metadata needed by tests is kept; + * authorization, cookies, and query values are intentionally excluded. + */ +class HermeticRequestJournal( + private val maxEntries: Int = 256, +) { + private val lock = Any() + private val nextId = AtomicLong() + private val entries = ArrayDeque() + private val matched = linkedMapOf() + private var active = 0 + private var generation = 0L + + val generationId: Long + get() = synchronized(lock) { generation } + + val activeRequestCount: Int + get() = synchronized(lock) { active } + + fun reset() = synchronized(lock) { + check(active == 0) { "Cannot reset with $active active request(s)" } + entries.clear() + matched.clear() + active = 0 + generation += 1 + } + + fun begin(request: RecordedRequest, routeId: String?): Long = + synchronized(lock) { + val id = nextId.incrementAndGet() + routeId?.let { matched[it] = (matched[it] ?: 0) + 1 } + active += 1 + add( + RequestEntry( + id = id, + method = request.method, + path = request.url.encodedPath.ifBlank { "/" }, + queryKeys = request.url.queryParameterNames.toList().sorted(), + headers = selectedHeaders(request), + range = request.headers["Range"], + routeId = routeId, + outcome = null, + ), + ) + id + } + + fun complete(requestId: Long, outcome: ResponseOutcome) = synchronized(lock) { + val index = entries.indexOfFirst { it.id == requestId } + if (index >= 0 && entries[index].outcome == null) { + entries[index] = entries[index].copy(outcome = outcome) + active = (active - 1).coerceAtLeast(0) + } + } + + fun matchedCount(routeId: String): Int = synchronized(lock) { + matched[routeId] ?: 0 + } + + fun snapshot(): Snapshot = synchronized(lock) { + Snapshot( + generationId = generation, + entries = entries.toList(), + matchedRoutes = matched.toMap(), + activeRequestCount = active, + ) + } + + private fun add(entry: RequestEntry) { + entries.addLast(entry) + while (entries.size > maxEntries) entries.removeFirst() + } + + private fun selectedHeaders(request: RecordedRequest): Map = + SELECTED_HEADERS.mapNotNull { name -> + request.headers[name]?.let { name to it.take(MAX_HEADER_LENGTH) } + }.toMap() + + data class Snapshot( + val generationId: Long, + val entries: List, + val matchedRoutes: Map, + val activeRequestCount: Int, + ) { + val unknownRequests: List + get() = entries.filter { it.routeId == null } + } + + data class RequestEntry( + val id: Long, + val method: String, + val path: String, + val queryKeys: List, + val headers: Map, + val range: String?, + val routeId: String?, + val outcome: ResponseOutcome?, + ) + + private companion object { + const val MAX_HEADER_LENGTH = 256 + val SELECTED_HEADERS = listOf( + "Accept", + "Cache-Control", + "Content-Type", + "Pragma", + ) + } +} + +sealed interface ResponseOutcome { + data class Completed(val status: Int) : ResponseOutcome + data object UnknownRoute : ResponseOutcome +} diff --git a/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServer.kt b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServer.kt new file mode 100644 index 00000000..8b8e5698 --- /dev/null +++ b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServer.kt @@ -0,0 +1,522 @@ +package com.kino.puber.playertestfixtures.server + +import java.io.Closeable +import java.net.InetAddress +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import mockwebserver3.Dispatcher +import mockwebserver3.MockResponse +import mockwebserver3.MockResponseBody +import mockwebserver3.MockWebServer +import mockwebserver3.RecordedRequest +import mockwebserver3.SocketEffect +import okhttp3.HttpUrl +import okio.BufferedSink + +/** + * A deterministic, loopback-only HTTP server for host and instrumentation + * player tests. Routes are matched by request identity rather than queue + * order, so concurrent Media3 requests are safe to dispatch. + */ +class HermeticTestServer( + private val port: Int = 0, +) : Closeable { + + private val server = MockWebServer() + private val lock = Any() + private val journal = HermeticRequestJournal() + private var routes: List = emptyList() + private var started = false + + internal var beforeRequestAdmissionForTest: () -> Unit = {} + + val baseUrl: String + get() { + check(started) { "Call start() before reading baseUrl" } + return server.url("/").toString() + } + + val generationId: Long + get() = journal.generationId + + val requestJournal: HermeticRequestJournal.Snapshot + get() = journal.snapshot() + + val activeRequestCount: Int + get() = journal.activeRequestCount + + fun start() { + synchronized(lock) { + check(!started) { "HermeticTestServer is already started" } + server.dispatcher = dispatcher() + server.start(InetAddress.getByName("127.0.0.1"), port) + started = true + } + } + + fun reset(newRoutes: List) { + synchronized(lock) { + check(started) { "Call start() before reset()" } + journal.reset() + routes = newRoutes.toList() + } + } + + fun addRoute(route: HermeticRoute) { + synchronized(lock) { + check(started) { "Call start() before addRoute()" } + routes = routes + route + } + } + + fun takeRequest( + timeout: Long, + unit: TimeUnit, + ): RecordedRequest? = server.takeRequest(timeout, unit) + + fun route( + id: String, + method: String = "GET", + path: String, + query: Map = emptyMap(), + queryMode: QueryMatchMode = QueryMatchMode.Exact, + response: ResponsePlan, + required: Boolean = false, + minimumRequests: Int = 1, + ): HermeticRoute = HermeticRoute( + id = id, + method = method, + path = path, + query = query, + queryMode = queryMode, + response = response, + required = required, + minimumRequests = minimumRequests, + ) + + fun url(path: String, query: Map = emptyMap()): String { + check(started) { "Call start() before url()" } + return server.url(path).newBuilder().apply { + query.forEach { (name, value) -> addQueryParameter(name, value) } + }.build().toString() + } + + fun awaitQuiescence( + timeout: Long = 5, + unit: TimeUnit = TimeUnit.SECONDS, + ) { + val deadline = System.nanoTime() + unit.toNanos(timeout) + while (System.nanoTime() < deadline) { + if (activeRequestCount == 0) return + Thread.yield() + } + error("Hermetic server still has $activeRequestCount active request(s)") + } + + fun verifyRequiredRoutes(): List = + synchronized(lock) { + routes + .filter { it.required && journal.matchedCount(it.id) < it.minimumRequests } + .map { it.description } + } + + override fun close() { + synchronized(lock) { + if (!started) return + started = false + server.close() + } + } + + private fun dispatcher() = object : Dispatcher() { + override fun dispatch(request: RecordedRequest): MockResponse { + val (route, requestId) = synchronized(lock) { + val selectedRoute = routes.firstOrNull { it.matches(request) } + beforeRequestAdmissionForTest() + selectedRoute to journal.begin(request, selectedRoute?.id) + } + if (route == null) { + return ResponsePlan.Text( + status = 404, + body = """{"error":"unknown hermetic route"}""", + contentType = "application/json; charset=utf-8", + ).toMockResponse(request) { + journal.complete(requestId, ResponseOutcome.UnknownRoute) + } + } + + val occurrence = journal.matchedCount(route.id) + return route.response.responseFor(request, occurrence).toMockResponse(request) { + journal.complete(requestId, ResponseOutcome.Completed(it)) + } + } + } + + companion object { + fun bytes( + body: ByteArray, + status: Int = 200, + contentType: String = "application/octet-stream", + ): ResponsePlan = ResponsePlan.Bytes(status, body, contentType) + + fun text( + body: String, + status: Int = 200, + contentType: String = "text/plain; charset=utf-8", + ): ResponsePlan = ResponsePlan.Text(status, body, contentType) + + fun redirect(location: String, status: Int = 302): ResponsePlan = + ResponsePlan.Redirect(status, location) + + fun sequence(vararg responses: ResponsePlan): ResponsePlan = + ResponsePlan.Sequence(responses.toList()) + + fun delayed( + gate: CountDownLatch, + body: ByteArray, + status: Int = 200, + contentType: String = "application/octet-stream", + ): ResponsePlan = ResponsePlan.Delayed(status, body, contentType, gate) + + fun truncated( + body: ByteArray, + bytesToWrite: Int, + status: Int = 200, + contentType: String = "application/octet-stream", + ): ResponsePlan = ResponsePlan.Truncated(status, body, contentType, bytesToWrite) + + fun disconnected( + body: ByteArray = ByteArray(0), + status: Int = 200, + contentType: String = "application/octet-stream", + ): ResponsePlan = ResponsePlan.Disconnected(status, body, contentType) + } +} + +data class HermeticRoute( + val id: String, + val method: String, + val path: String, + val query: Map, + val queryMode: QueryMatchMode, + val response: ResponsePlan, + val required: Boolean, + val minimumRequests: Int, +) { + val description: String + get() = buildString { + append(method) + append(' ') + append(path) + if (query.isNotEmpty()) { + append('?') + append(query.entries.joinToString("&") { "${it.key}=${it.value}" }) + } + } + + fun matches(request: RecordedRequest): Boolean = + (method == "*" || method.equals(request.method, ignoreCase = true)) && + matches(request.url) + + fun matches(url: HttpUrl): Boolean { + val expectedPath = path.trimEnd('/').ifEmpty { "/" } + val actualPath = url.encodedPath.trimEnd('/').ifEmpty { "/" } + if (actualPath != expectedPath) return false + val actualQuery = url.queryParameterNames.associateWith { name -> + url.queryParameter(name).orEmpty() + } + return when (queryMode) { + QueryMatchMode.Exact -> actualQuery == query + QueryMatchMode.Contains -> query.all { actualQuery[it.key] == it.value } + } + } +} + +enum class QueryMatchMode { + Exact, + Contains, +} + +sealed interface ResponsePlan { + fun responseFor(request: RecordedRequest, occurrence: Int): ResponsePlan = + this + + fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse + + data class Bytes( + val status: Int, + val body: ByteArray, + val contentType: String, + val headers: Map = emptyMap(), + ) : ResponsePlan { + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse = + MockResponse.Builder() + .code(status) + .addHeader("Content-Type", contentType) + .addHeader("Connection", "close") + .apply { + this@Bytes.headers.forEach { (name, value) -> + addHeader(name, value) + } + } + .body( + completedBody( + body = body, + status = status, + onComplete = onComplete, + declaredLength = body.size.toLong(), + ), + ) + .build() + } + + data class Text( + val status: Int, + val body: String, + val contentType: String, + val headers: Map = emptyMap(), + ) : ResponsePlan { + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse = + Bytes(status, body.toByteArray(), contentType, headers) + .toMockResponse(request, onComplete) + } + + data class Redirect( + val status: Int, + val location: String, + ) : ResponsePlan { + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse = + MockResponse.Builder() + .code(status) + .addHeader("Location", location) + .addHeader("Connection", "close") + .body( + completedBody( + body = ByteArray(0), + status = status, + onComplete = onComplete, + declaredLength = 0, + ), + ) + .build() + } + + data class Sequence( + val responses: List, + ) : ResponsePlan { + init { + require(responses.isNotEmpty()) { "A response sequence cannot be empty" } + } + + override fun responseFor(request: RecordedRequest, occurrence: Int): ResponsePlan = + responses[(occurrence - 1).coerceAtMost(responses.lastIndex)] + + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse = + responses.last().toMockResponse(request, onComplete) + } + + data class Delayed( + val status: Int, + val body: ByteArray, + val contentType: String, + val gate: CountDownLatch, + ) : ResponsePlan { + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse = + MockResponse.Builder() + .code(status) + .addHeader("Content-Type", contentType) + .addHeader("Connection", "close") + .body( + completedBody( + body = body, + status = status, + onComplete = onComplete, + gate = gate, + declaredLength = body.size.toLong(), + ), + ) + .build() + } + + data class Truncated( + val status: Int, + val body: ByteArray, + val contentType: String, + val bytesToWrite: Int, + ) : ResponsePlan { + init { + require(bytesToWrite in 0..body.size) { + "bytesToWrite must be between zero and body size" + } + } + + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse { + val partial = body.copyOf(bytesToWrite) + return MockResponse.Builder() + .code(status) + .addHeader("Content-Type", contentType) + .addHeader("Connection", "close") + .body( + completedBody( + body = partial, + status = status, + onComplete = onComplete, + declaredLength = body.size.toLong(), + ), + ) + .setHeader("Content-Length", body.size) + .onResponseEnd(SocketEffect.CloseSocket()) + .build() + } + } + + data class Disconnected( + val status: Int, + val body: ByteArray, + val contentType: String, + ) : ResponsePlan { + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse = + MockResponse.Builder() + .code(status) + .addHeader("Content-Type", contentType) + .addHeader("Connection", "close") + .body( + completedBody( + body = body, + status = status, + onComplete = onComplete, + declaredLength = body.size.toLong(), + ), + ) + .onResponseBody(SocketEffect.CloseSocket()) + .build() + } + + data class Range( + val body: ByteArray, + val contentType: String = "application/octet-stream", + val status: Int = 200, + ) : ResponsePlan { + override fun responseFor(request: RecordedRequest, occurrence: Int): ResponsePlan { + val range = parseRange(request.headers["Range"], body.size) + ?: return Bytes(status, body, contentType) + return Bytes( + status = 206, + body = body.copyOfRange(range.first, range.last + 1), + contentType = contentType, + headers = mapOf( + "Accept-Ranges" to "bytes", + "Content-Range" to "bytes ${range.first}-${range.last}/${body.size}", + ), + ) + } + + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse = + Bytes(status, body, contentType, mapOf("Accept-Ranges" to "bytes")) + .toMockResponse(request, onComplete) + } + + class Dynamic( + private val handler: (RecordedRequest) -> MockResponse, + ) : ResponsePlan { + override fun toMockResponse( + request: RecordedRequest, + onComplete: (status: Int) -> Unit, + ): MockResponse { + val response = handler(request) + val responseBody = response.body + val body = responseBody + ?: completedBody(ByteArray(0), response.code, onComplete, declaredLength = 0) + return response.newBuilder() + .body( + if (responseBody == null) body + else completedBody(responseBody, response.code, onComplete), + ) + .build() + } + } +} + +private fun completedBody( + body: ByteArray, + status: Int, + onComplete: (status: Int) -> Unit, + gate: CountDownLatch? = null, + declaredLength: Long, +): MockResponseBody = + object : MockResponseBody { + override val contentLength: Long = declaredLength + + override fun writeTo(sink: BufferedSink) { + try { + if (gate != null) { + check(gate.await(10, TimeUnit.SECONDS)) { + "Response gate was not released" + } + } + sink.write(body) + sink.flush() + onComplete(status) + } catch (error: Throwable) { + onComplete(599) + throw error + } + } + } + +private fun completedBody( + body: MockResponseBody, + status: Int, + onComplete: (status: Int) -> Unit, +): MockResponseBody = + object : MockResponseBody { + override val contentLength: Long = body.contentLength + + override fun writeTo(sink: BufferedSink) { + try { + body.writeTo(sink) + sink.flush() + onComplete(status) + } catch (error: Throwable) { + onComplete(599) + throw error + } + } + } + +private fun parseRange(header: String?, size: Int): IntRange? { + if (header == null || !header.startsWith("bytes=")) return null + val values = header.removePrefix("bytes=").substringBefore(',').split('-', limit = 2) + if (values.size != 2) return null + val start = values[0].toIntOrNull() ?: return null + val end = values[1].toIntOrNull() ?: size - 1 + if (start < 0 || start >= size || end < start) return null + return start..end.coerceAtMost(size - 1) +} diff --git a/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt b/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt new file mode 100644 index 00000000..55739418 --- /dev/null +++ b/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt @@ -0,0 +1,116 @@ +package com.kino.puber.playertestfixtures + +import java.security.MessageDigest +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class PlayerTestFixturesTest { + + @Test + fun everyCatalogEntry_isPresentAndMatchesCommittedSha256() { + val catalog = PlayerTestFixtures.catalog + + assertEquals(FixtureId.entries.toSet(), catalog.all.map(FixtureMetadata::id).toSet()) + FixtureId.entries.forEach { fixture -> + assertTrue("$fixture is missing or changed", PlayerTestFixtures.verifySha256(fixture)) + } + } + + @Test + fun everyCommittedPackFile_matchesItsSha256AndExpectedFileSet() { + val checksums = PlayerTestFixtures.committedChecksums() + + assertEquals( + setOf( + "fixture-manifest.properties", + "hls/audio_english_000.ts", + "hls/audio_english_001.ts", + "hls/audio_english_002.ts", + "hls/audio_english.m3u8", + "hls/audio_spanish_000.ts", + "hls/audio_spanish_001.ts", + "hls/audio_spanish_002.ts", + "hls/audio_spanish.m3u8", + "hls/master.m3u8", + "hls/video_360_000.ts", + "hls/video_360_001.ts", + "hls/video_360.m3u8", + "hls/video_720_000.ts", + "hls/video_720_001.ts", + "hls/video_720.m3u8", + "progressive.mp4", + "subtitle.vtt", + ), + checksums.keys, + ) + checksums.forEach { (path, expected) -> + val actual = MessageDigest.getInstance("SHA-256") + .digest(PlayerTestFixtures.openPath(path).use { it.readBytes() }) + .joinToString("") { "%02x".format(it) } + assertEquals(path, expected, actual) + } + } + + @Test + fun catalog_containsPlaybackTracksAndKnownSubtitleCue() { + val catalog = PlayerTestFixtures.catalog + + assertEquals(4_000L, catalog.metadata(FixtureId.ProgressiveMp4).durationMs) + assertEquals("en", catalog.metadata(FixtureId.HlsAudioEnglishPlaylist).language) + assertEquals("EspaƱol", catalog.metadata(FixtureId.HlsAudioSpanishPlaylist).label) + assertEquals(1_000L, catalog.metadata(FixtureId.SubtitleWebVtt).cueStartMs) + assertEquals(2_000L, catalog.metadata(FixtureId.SubtitleWebVtt).cueEndMs) + } + + @Test + fun hlsMaster_referencesBothVideoVariantsAndAudioRenditions() { + val master = PlayerTestFixtures.readBytes(FixtureId.HlsMaster).decodeToString() + + assertTrue(master.contains("video_360.m3u8")) + assertTrue(master.contains("video_720.m3u8")) + assertTrue(master.contains("RESOLUTION=640x360")) + assertTrue(master.contains("RESOLUTION=1280x720")) + assertTrue(master.contains("audio_english.m3u8")) + assertTrue(master.contains("audio_spanish.m3u8")) + } + + @Test + fun everyHlsPlaylist_referencesCommittedSegments() { + listOf( + FixtureId.HlsVideo360Playlist, + FixtureId.HlsVideo720Playlist, + FixtureId.HlsAudioEnglishPlaylist, + FixtureId.HlsAudioSpanishPlaylist, + ).forEach { playlist -> + val segments = PlayerTestFixtures.readBytes(playlist) + .decodeToString() + .lineSequence() + .filter { it.endsWith(".ts") } + .toList() + + assertTrue("$playlist must contain at least two segments", segments.size >= 2) + segments.forEach { segment -> + val path = "${playlist.path.substringBeforeLast('/')}/$segment" + assertTrue("$path is not in the committed checksum manifest", path in PlayerTestFixtures.committedChecksums()) + PlayerTestFixtures.openPath(path).use { input -> + assertTrue("$path is empty", input.readBytes().isNotEmpty()) + } + } + } + } + + @Test + fun fixtureHashes_useSha256LowercaseHex() { + PlayerTestFixtures.catalog.all.forEach { metadata -> + assertEquals(64, metadata.sha256.length) + assertEquals(metadata.sha256.lowercase(), metadata.sha256) + assertEquals( + metadata.sha256, + MessageDigest.getInstance("SHA-256") + .digest(PlayerTestFixtures.readBytes(metadata.id)) + .joinToString("") { "%02x".format(it) }, + ) + } + } +} diff --git a/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServerTest.kt b/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServerTest.kt new file mode 100644 index 00000000..33a0d486 --- /dev/null +++ b/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/server/HermeticTestServerTest.kt @@ -0,0 +1,311 @@ +package com.kino.puber.playertestfixtures.server + +import java.net.HttpURLConnection +import java.net.URL +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicReference +import org.junit.Assert.assertArrayEquals +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 HermeticTestServerTest { + + @Test + fun routesMatchMethodPathAndQueryWithoutQueueOrderAndRedactValues() { + HermeticTestServer().use { server -> + server.start() + server.reset( + listOf( + server.route( + id = "serial", + path = "/v1/items", + query = mapOf("type" to "serial"), + response = HermeticTestServer.text("serial"), + ), + server.route( + id = "movie", + path = "/v1/items", + query = mapOf("type" to "movie"), + response = HermeticTestServer.text("movie"), + ), + ), + ) + + assertEquals("serial", request(server.url("/v1/items", mapOf("type" to "serial"))).text) + assertEquals("movie", request(server.url("/v1/items", mapOf("type" to "movie"))).text) + + val snapshot = server.requestJournal + assertTrue(snapshot.entries.all { "type" in it.queryKeys }) + assertTrue(snapshot.entries.none { it.path.contains("serial") || it.path.contains("movie") }) + assertEquals(0, snapshot.activeRequestCount) + } + } + + @Test + fun sequenceRedirectAndRangeResponsesAreDeterministic() { + HermeticTestServer().use { server -> + server.start() + server.reset( + listOf( + server.route( + id = "sequence", + path = "/sequence", + response = HermeticTestServer.sequence( + HermeticTestServer.text("first", status = 503), + HermeticTestServer.text("second"), + ), + ), + server.route( + id = "redirect", + path = "/redirect", + response = HermeticTestServer.redirect("/sequence"), + ), + server.route( + id = "range", + path = "/range", + response = ResponsePlan.Range("abcdef".toByteArray()), + ), + ), + ) + + assertEquals(503, request(server.url("/sequence")).status) + assertEquals(200, request(server.url("/sequence")).status) + val redirect = request(server.url("/redirect"), followRedirects = false) + assertEquals(302, redirect.status) + assertEquals("/sequence", redirect.location) + val range = request(server.url("/range"), range = "bytes=1-3") + assertEquals(206, range.status) + assertArrayEquals("bcd".toByteArray(), range.bytes) + assertEquals("bytes 1-3/6", range.contentRange ?: range.headers.toString()) + } + } + + @Test + fun unknownRoutesAreRecordedAndDelayedResponsesTrackActiveRequests() { + HermeticTestServer().use { server -> + server.start() + val gate = CountDownLatch(1) + server.reset( + listOf( + server.route( + id = "delayed", + path = "/delayed", + response = HermeticTestServer.delayed(gate, "payload".toByteArray()), + ), + ), + ) + + val unknown = request(server.url("/unexpected?token=secret"), followRedirects = false) + assertEquals(404, unknown.status) + val requestThread = Thread { + request(server.url("/delayed")) + } + requestThread.start() + eventually { server.activeRequestCount == 1 } + assertTrue(server.requestJournal.entries.none { it.path.contains("secret") }) + gate.countDown() + requestThread.join(5_000) + assertFalse(requestThread.isAlive) + server.awaitQuiescence() + assertEquals(1, server.requestJournal.unknownRequests.size) + } + } + + @Test + fun resetStartsNewGenerationOnlyAfterRequestsQuiesce() { + HermeticTestServer().use { server -> + server.start() + server.reset( + listOf( + server.route( + id = "first", + path = "/first", + response = HermeticTestServer.text("first"), + ), + ), + ) + val firstGeneration = server.generationId + request(server.url("/first")) + server.reset( + listOf( + server.route( + id = "second", + path = "/second", + response = HermeticTestServer.text("second"), + ), + ), + ) + assertTrue(server.generationId > firstGeneration) + assertEquals(0, server.requestJournal.entries.size) + assertEquals(404, request(server.url("/first")).status) + assertEquals(200, request(server.url("/second")).status) + } + } + + @Test + fun concurrentResetCannotReplaceRoutesBeforeRequestAdmission() { + HermeticTestServer().use { server -> + server.start() + val admissionSelected = CountDownLatch(1) + val allowAdmission = CountDownLatch(1) + val allowResponse = CountDownLatch(1) + server.beforeRequestAdmissionForTest = { + admissionSelected.countDown() + check(allowAdmission.await(5, TimeUnit.SECONDS)) { + "Timed out waiting to admit selected route" + } + } + server.reset( + listOf( + server.route( + id = "delayed-old", + path = "/delayed-old", + response = HermeticTestServer.delayed( + gate = allowResponse, + body = "old".toByteArray(), + ), + ), + server.route( + id = "old-only", + path = "/old-only", + response = HermeticTestServer.text("old-only"), + ), + ), + ) + val firstGeneration = server.generationId + val requestResult = AtomicReference() + val requestFailure = AtomicReference() + val requestThread = Thread { + runCatching { request(server.url("/delayed-old")) } + .onSuccess(requestResult::set) + .onFailure(requestFailure::set) + } + requestThread.start() + assertTrue(admissionSelected.await(5, TimeUnit.SECONDS)) + + val resetFailure = AtomicReference() + val resetThread = Thread { + runCatching { + server.reset( + listOf( + server.route( + id = "new-only", + path = "/new-only", + response = HermeticTestServer.text("new-only"), + ), + ), + ) + }.onFailure(resetFailure::set) + } + resetThread.start() + allowAdmission.countDown() + resetThread.join(5_000) + + assertFalse(resetThread.isAlive) + assertTrue(resetFailure.get() is IllegalStateException) + assertEquals(firstGeneration, server.generationId) + allowResponse.countDown() + requestThread.join(5_000) + assertFalse(requestThread.isAlive) + assertNull(requestFailure.get()) + assertEquals("old", requestResult.get().text) + assertEquals("old-only", request(server.url("/old-only")).text) + assertEquals(404, request(server.url("/new-only")).status) + + server.awaitQuiescence() + server.beforeRequestAdmissionForTest = {} + server.reset( + listOf( + server.route( + id = "new-only", + path = "/new-only", + response = HermeticTestServer.text("new-only"), + ), + ), + ) + + assertTrue(server.generationId > firstGeneration) + assertEquals(404, request(server.url("/old-only")).status) + assertEquals("new-only", request(server.url("/new-only")).text) + assertEquals(1, server.requestJournal.unknownRequests.size) + } + } + + @Test + fun truncationAndDisconnectAreObservableWithoutLeakingActiveRequests() { + HermeticTestServer().use { server -> + server.start() + server.reset( + listOf( + server.route( + id = "truncated", + path = "/truncated", + response = HermeticTestServer.truncated( + body = "complete".toByteArray(), + bytesToWrite = 2, + ), + ), + server.route( + id = "disconnected", + path = "/disconnected", + response = HermeticTestServer.disconnected( + body = "interrupted".toByteArray(), + ), + ), + ), + ) + + val truncated = request(server.url("/truncated")) + assertArrayEquals("co".toByteArray(), truncated.bytes) + val disconnected = request(server.url("/disconnected")) + assertTrue(disconnected.bytes.size < "interrupted".length) + server.awaitQuiescence() + assertEquals(0, server.requestJournal.activeRequestCount) + assertEquals(2, server.requestJournal.entries.size) + } + } + + private fun eventually(predicate: () -> Boolean) { + val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(2) + while (System.nanoTime() < deadline && !predicate()) Thread.yield() + assertTrue(predicate()) + } + + private fun request( + url: String, + followRedirects: Boolean = true, + range: String? = null, + ): Response { + val connection = URL(url).openConnection() as HttpURLConnection + connection.instanceFollowRedirects = followRedirects + range?.let { connection.setRequestProperty("Range", it) } + return try { + val status = connection.responseCode + val stream = if (status >= 400) connection.errorStream else connection.inputStream + val bytes = stream?.use { it.readBytes() } ?: ByteArray(0) + Response( + status = status, + bytes = bytes, + text = String(bytes), + location = connection.getHeaderField("Location"), + contentRange = connection.getHeaderField("Content-Range"), + headers = connection.headerFields, + ) + } finally { + connection.disconnect() + } + } + + private data class Response( + val status: Int, + val bytes: ByteArray, + val text: String, + val location: String?, + val contentRange: String?, + val headers: Map>, + ) +} diff --git a/settings.gradle.kts b/settings.gradle.kts index 34e823b2..1ff48e4c 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -21,4 +21,5 @@ dependencyResolutionManagement { rootProject.name = "Puber" include(":app") -include(":baselineprofile") \ No newline at end of file +include(":baselineprofile") +include(":player-test-fixtures") diff --git a/tools/generate-player-test-fixtures.sh b/tools/generate-player-test-fixtures.sh new file mode 100755 index 00000000..8d005cbe --- /dev/null +++ b/tools/generate-player-test-fixtures.sh @@ -0,0 +1,200 @@ +#!/usr/bin/env bash +set -euo pipefail + +readonly SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)" +readonly REPO_ROOT="$(cd -- "$SCRIPT_DIR/.." && pwd)" +readonly MODULE_ROOT="$REPO_ROOT/player-test-fixtures" +readonly DEFAULT_OUTPUT="$MODULE_ROOT/src/main/assets/player-fixtures" +readonly FFMPEG_VERSION_REQUIRED="9.0.1" + +output="$DEFAULT_OUTPUT" +force=0 + +usage() { + echo "Usage: $0 [--output DIR] [--force]" >&2 +} + +while (($# > 0)); do + case "$1" in + --output) + (($# >= 2)) || { usage; exit 2; } + output="$2" + shift 2 + ;; + --force) + force=1 + shift + ;; + -h|--help) + usage + exit 0 + ;; + *) + usage + exit 2 + ;; + esac +done + +ffmpeg_bin="${FFMPEG_BIN:-$(command -v ffmpeg || true)}" +if [[ -z "$ffmpeg_bin" || ! -x "$ffmpeg_bin" ]]; then + echo "ffmpeg is required; install version $FFMPEG_VERSION_REQUIRED" >&2 + exit 1 +fi + +ffmpeg_version="$("$ffmpeg_bin" -version | sed -n '1s/^ffmpeg version \([^ ]*\).*/\1/p')" +if [[ "$ffmpeg_version" != "$FFMPEG_VERSION_REQUIRED" ]]; then + echo "Unsupported ffmpeg version '$ffmpeg_version'; expected $FFMPEG_VERSION_REQUIRED" >&2 + exit 1 +fi + +case "$output" in + "$MODULE_ROOT"/src/main/assets/player-fixtures|"$REPO_ROOT"/player-test-fixtures/src/main/assets/player-fixtures) + ;; + *) + echo "Refusing to write outside the fixture output directory: $output" >&2 + exit 1 + ;; +esac + +if [[ -e "$output" ]]; then + if ((force == 0)); then + echo "$output already exists; pass --force for an explicit regeneration" >&2 + exit 1 + fi + rm -rf -- "$output" +fi + +mkdir -p "$output/hls" +temp_dir="$(mktemp -d "${TMPDIR:-/tmp}/puber-player-fixtures.XXXXXX")" +trap 'rm -rf -- "$temp_dir"' EXIT + +common_video_args=( + -hide_banner -loglevel error -y + -fflags +bitexact + -threads 1 +) + +"$ffmpeg_bin" "${common_video_args[@]}" \ + -f lavfi -i "testsrc2=size=640x360:rate=30" \ + -f lavfi -i "sine=frequency=440:sample_rate=48000" \ + -t 4 -shortest \ + -map_metadata -1 \ + -c:v libx264 -preset veryfast -profile:v baseline -level 3.0 \ + -pix_fmt yuv420p -r 30 -g 60 -keyint_min 60 -sc_threshold 0 \ + -b:v 800k -c:a aac -b:a 96k -ar 48000 \ + -movflags +faststart \ + "$output/progressive.mp4" + +generate_video_playlist() { + local width="$1" + local height="$2" + local bitrate="$3" + local name="$4" + "$ffmpeg_bin" "${common_video_args[@]}" \ + -i "$output/progressive.mp4" -map 0:v:0 -an \ + -vf "scale=${width}:${height}:flags=bilinear" \ + -map_metadata -1 \ + -c:v libx264 -preset veryfast -profile:v baseline -level 3.0 \ + -pix_fmt yuv420p -r 30 -g 60 -keyint_min 60 -sc_threshold 0 \ + -b:v "$bitrate" -force_key_frames "expr:gte(t,n_forced*2)" \ + -f hls -hls_time 2 -hls_playlist_type vod \ + -hls_flags independent_segments \ + -hls_segment_filename "$temp_dir/${name}_%03d.ts" \ + "$temp_dir/${name}.m3u8" + cp "$temp_dir/${name}.m3u8" "$output/hls/${name}.m3u8" + cp "$temp_dir/${name}"_*.ts "$output/hls/" +} + +generate_video_playlist 640 360 700k video_360 +generate_video_playlist 1280 720 1.4M video_720 + +generate_audio_playlist() { + local frequency="$1" + local name="$2" + "$ffmpeg_bin" "${common_video_args[@]}" \ + -f lavfi -i "sine=frequency=${frequency}:sample_rate=48000" \ + -t 4 -vn -map_metadata -1 -c:a aac -b:a 96k -ar 48000 \ + -f hls -hls_time 2 -hls_playlist_type vod \ + -hls_flags independent_segments \ + -hls_segment_filename "$temp_dir/${name}_%03d.ts" \ + "$temp_dir/${name}.m3u8" + cp "$temp_dir/${name}.m3u8" "$output/hls/${name}.m3u8" + cp "$temp_dir/${name}"_*.ts "$output/hls/" +} + +generate_audio_playlist 440 audio_english +generate_audio_playlist 660 audio_spanish + +( + cd "$output/hls" + { + echo '#EXTM3U' + echo '#EXT-X-VERSION:3' + echo '#EXT-X-INDEPENDENT-SEGMENTS' + echo '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="English",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,URI="audio_english.m3u8"' + echo '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="EspaƱol",LANGUAGE="es",DEFAULT=NO,AUTOSELECT=YES,URI="audio_spanish.m3u8"' + echo '#EXT-X-STREAM-INF:BANDWIDTH=800000,RESOLUTION=640x360,CODECS="avc1.42c01e,mp4a.40.2",AUDIO="audio"' + echo 'video_360.m3u8' + echo '#EXT-X-STREAM-INF:BANDWIDTH=1500000,RESOLUTION=1280x720,CODECS="avc1.42c01e,mp4a.40.2",AUDIO="audio"' + echo 'video_720.m3u8' + } > master.m3u8 +) + +cat > "$output/subtitle.vtt" <<'EOF' +WEBVTT + +00:00:01.000 --> 00:00:02.000 +Synthetic player fixture cue +EOF + +hash_for() { + shasum -a 256 "$output/$1" | awk '{print $1}' +} + +{ + echo "# Generated by tools/generate-player-test-fixtures.sh" + echo + echo "Tool: ffmpeg $ffmpeg_version" + echo "Inputs: lavfi testsrc2 video pattern and lavfi sine tones at 440 Hz and 660 Hz." + echo "Container: progressive H.264/AAC MP4; HLS MPEG-TS VOD playlists with two video variants and two AAC renditions." + echo "Duration: 4 seconds; segment target: 2 seconds." + echo "The generated bytes are committed. Gradle and tests verify hashes and do not transcode." + echo "Regeneration is a maintainer action and requires the exact ffmpeg version above." +} > "$MODULE_ROOT/fixtures-provenance.md" + +{ + echo "# Generated by tools/generate-player-test-fixtures.sh" + echo "fixture.ProgressiveMp4.duration_ms=4000" + echo "fixture.ProgressiveMp4.sha256=$(hash_for progressive.mp4)" + echo "fixture.HlsMaster.sha256=$(hash_for hls/master.m3u8)" + echo "fixture.HlsVideo360Playlist.duration_ms=4000" + echo "fixture.HlsVideo360Playlist.sha256=$(hash_for hls/video_360.m3u8)" + echo "fixture.HlsVideo720Playlist.duration_ms=4000" + echo "fixture.HlsVideo720Playlist.sha256=$(hash_for hls/video_720.m3u8)" + echo "fixture.HlsAudioEnglishPlaylist.duration_ms=4000" + echo "fixture.HlsAudioEnglishPlaylist.language=en" + echo "fixture.HlsAudioEnglishPlaylist.label=English" + echo "fixture.HlsAudioEnglishPlaylist.sha256=$(hash_for hls/audio_english.m3u8)" + echo "fixture.HlsAudioSpanishPlaylist.duration_ms=4000" + echo "fixture.HlsAudioSpanishPlaylist.language=es" + echo "fixture.HlsAudioSpanishPlaylist.label=EspaƱol" + echo "fixture.HlsAudioSpanishPlaylist.sha256=$(hash_for hls/audio_spanish.m3u8)" + echo "fixture.SubtitleWebVtt.cue_start_ms=1000" + echo "fixture.SubtitleWebVtt.cue_end_ms=2000" + echo "fixture.SubtitleWebVtt.sha256=$(hash_for subtitle.vtt)" +} > "$output/fixture-manifest.properties" + +{ + echo "# Generated by tools/generate-player-test-fixtures.sh" + echo "# Paths are relative to player-test-fixtures/src/main/assets/player-fixtures" + find "$output" -type f ! -name SHA256SUMS -print | + sed "s#^$output/##" | + sort | + while read -r path; do + printf '%s %s\n' "$(hash_for "$path")" "$path" + done +} > "$output/SHA256SUMS" +cp "$output/SHA256SUMS" "$MODULE_ROOT/SHA256SUMS" + +echo "Generated fixture pack at $output" diff --git a/tools/resolve-android-test-apk-pair b/tools/resolve-android-test-apk-pair new file mode 100755 index 00000000..5e5947b1 --- /dev/null +++ b/tools/resolve-android-test-apk-pair @@ -0,0 +1,171 @@ +#!/usr/bin/env bash +set -euo pipefail + +pairing_contract="" +expected_target_id="" +expected_test_id="" +target_metadata="" +test_metadata="" +built_after="" + +die() { + echo "resolve-android-test-apk-pair: $*" >&2 + exit 1 +} + +if [[ -n "${APKANALYZER:-}" ]]; then + analyzer="$APKANALYZER" +else + analyzer="" + for candidate in \ + "${ANDROID_HOME:-}/cmdline-tools/latest/bin/apkanalyzer" \ + "${ANDROID_HOME:-}/cmdline-tools/17.0/bin/apkanalyzer" \ + "$(command -v apkanalyzer 2>/dev/null || true)"; do + if [[ -x "$candidate" ]]; then + analyzer="$candidate" + break + fi + done + [[ -n "$analyzer" ]] || die "apkanalyzer is not available" +fi + +usage() { + echo "Usage: $0 --pairing-contract CONTRACT [--expected-target-application-id ID] [--expected-test-application-id ID] --target-metadata FILE --test-metadata FILE --built-after EPOCH_SECONDS" >&2 +} + +while (($# > 0)); do + case "$1" in + --pairing-contract) pairing_contract="${2:?missing value}"; shift 2 ;; + --expected-target-application-id) expected_target_id="${2:?missing value}"; shift 2 ;; + --expected-test-application-id) expected_test_id="${2:?missing value}"; shift 2 ;; + --target-metadata) target_metadata="${2:?missing value}"; shift 2 ;; + --test-metadata) test_metadata="${2:?missing value}"; shift 2 ;; + --built-after) built_after="${2:?missing value}"; shift 2 ;; + -h|--help) usage; exit 0 ;; + *) usage; exit 2 ;; + esac +done + +[[ "$pairing_contract" == "app-android-test" || "$pairing_contract" == "standalone-self-target" ]] || + die "unsupported pairing contract" +[[ "$built_after" =~ ^[0-9]+$ ]] || die "--built-after must be epoch seconds" +[[ -n "$target_metadata" && -n "$test_metadata" ]] || die "both metadata paths are required" +if [[ "$pairing_contract" == "standalone-self-target" ]]; then + [[ -n "$expected_target_id" && -n "$expected_test_id" ]] || + die "standalone-self-target requires expected application IDs" +fi + +file_mtime() { + stat -f '%m' "$1" 2>/dev/null || stat -c '%Y' "$1" +} + +regular_non_symlink() { + [[ -f "$1" && ! -L "$1" ]] +} + +validate_metadata() { + local path="$1" + regular_non_symlink "$path" || die "metadata is not a regular non-symlink file: $path" + (( $(file_mtime "$path") >= built_after )) || die "metadata is stale: $path" + jq empty "$path" >/dev/null || die "metadata is not valid JSON: $path" +} + +resolve_apk() { + local metadata="$1" + local dir output candidate + dir="$(cd -- "$(dirname -- "$metadata")" && pwd -P)" + output="$(jq -r ' + if (.elements | type) != "array" then error("elements is not an array") else . end + | if (.elements | length) != 1 then error("expected exactly one output element") else . end + | .elements[0] + | if .type != "SINGLE" or ((.filters // []) | length) != 0 + then error("expected one unfiltered SINGLE output") else .outputFile end + ' "$metadata")" || die "metadata contains no unique unfiltered SINGLE output: $metadata" + [[ -n "$output" && "$output" != "null" ]] || die "metadata outputFile is missing: $metadata" + [[ "$output" != /* && "$output" != *$'\n'* && "$output" != *$'\r'* ]] || + die "outputFile must be a relative path: $output" + case "/$output/" in + */../*|*/..|../*) die "outputFile escapes metadata directory: $output" ;; + esac + candidate="$dir/$output" + regular_non_symlink "$candidate" || die "APK is not a regular non-symlink file: $candidate" + (( $(file_mtime "$candidate") >= built_after )) || die "APK is stale: $candidate" + printf '%s\n' "$candidate" +} + +manifest_print() { + "$analyzer" manifest print "$1" 2>/dev/null || die "apkanalyzer could not inspect $1" +} + +manifest_attr() { + local manifest="$1" + local element="$2" + local attribute="$3" + local flattened + flattened="$(printf '%s\n' "$manifest" | tr '\n' ' ')" + printf '%s\n' "$flattened" | + sed -nE "s#.*<$element([^>]*)/?>.*#\1#p" | + sed -nE "s#.*android:$attribute=\"([^\"]+)\".*#\1#p" +} + +application_id() { + "$analyzer" manifest application-id "$1" 2>/dev/null || die "application-id inspection failed: $1" +} + +validate_metadata "$target_metadata" +validate_metadata "$test_metadata" +target_apk="$(resolve_apk "$target_metadata")" +test_apk="$(resolve_apk "$test_metadata")" +target_manifest="$(manifest_print "$target_apk")" +test_manifest="$(manifest_print "$test_apk")" +[[ -n "$target_manifest" ]] || die "target manifest is empty: $target_apk" +[[ -n "$test_manifest" ]] || die "test manifest is empty: $test_apk" +target_id="$(application_id "$target_apk")" +test_id="$(application_id "$test_apk")" +runner="$(manifest_attr "$test_manifest" instrumentation name)" +target_package="$(manifest_attr "$test_manifest" instrumentation targetPackage)" + +[[ "$runner" == "androidx.test.runner.AndroidJUnitRunner" ]] || + die "unexpected instrumentation runner: $runner" +[[ -n "$target_package" ]] || die "instrumentation targetPackage is missing" + +case "$pairing_contract" in + app-android-test) + [[ "$target_package" == "$target_id" ]] || + die "app Android-test targetPackage '$target_package' does not match target '$target_id'" + ;; + standalone-self-target) + [[ "$target_id" == "$expected_target_id" ]] || + die "target application ID '$target_id' does not match expected '$expected_target_id'" + [[ "$test_id" == "$expected_test_id" ]] || + die "test application ID '$test_id' does not match expected '$expected_test_id'" + [[ "$target_package" == "$test_id" ]] || + die "standalone targetPackage '$target_package' does not match test '$test_id'" + ;; +esac + +jq -cn \ + --arg contract "$pairing_contract" \ + --arg target_path "$target_apk" \ + --arg test_path "$test_apk" \ + --arg target_application_id "$target_id" \ + --arg test_application_id "$test_id" \ + --arg target_package "$target_package" \ + --arg runner "$runner" \ + --arg target_sha256 "$(shasum -a 256 "$target_apk" | awk '{print $1}')" \ + --arg test_sha256 "$(shasum -a 256 "$test_apk" | awk '{print $1}')" \ + '{ + pairing_contract: $contract, + target: { + apk_path: $target_path, + application_id: $target_application_id, + sha256: $target_sha256 + }, + test: { + apk_path: $test_path, + application_id: $test_application_id, + target_package: $target_package, + runner: $runner, + sha256: $test_sha256 + } + }' diff --git a/tools/test-resolve-android-test-apk-pair b/tools/test-resolve-android-test-apk-pair new file mode 100755 index 00000000..80a4babf --- /dev/null +++ b/tools/test-resolve-android-test-apk-pair @@ -0,0 +1,159 @@ +#!/usr/bin/env bash +set -euo pipefail + +readonly ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)" +readonly RESOLVER="$ROOT/tools/resolve-android-test-apk-pair" +readonly TMP="$(mktemp -d "${TMPDIR:-/tmp}/puber-apk-pair-test.XXXXXX")" +trap 'rm -rf -- "$TMP"' EXIT + +fail() { + echo "FAIL: $*" >&2 + exit 1 +} + +assert_rejected() { + if "$@" >/dev/null 2>&1; then + fail "expected rejection: $*" + fi +} + +make_analyzer() { + local path="$TMP/apkanalyzer" + cat > "$path" <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [[ "$1 $2" == "manifest application-id" ]]; then + case "$3" in + *target.apk) echo "com.kino.puber.instrumentation" ;; + *app-test.apk) echo "com.kino.puber.instrumentation" ;; + *wrong-target-package.apk) echo "com.kino.puber.instrumentation" ;; + *wrong-runner.apk) echo "com.kino.puber.instrumentation" ;; + *baseline-test.apk) echo "com.kino.puber.baselineprofile" ;; + *) exit 1 ;; + esac +else + case "$3" in + *target.apk) echo '' ;; + *app-test.apk) echo '' ;; + *wrong-target-package.apk) echo '' ;; + *wrong-runner.apk) echo '' ;; + *baseline-test.apk) echo '' ;; + *) exit 1 ;; + esac +fi +EOF + chmod +x "$path" + echo "$path" +} + +write_metadata() { + local metadata="$1" + local apk_name="$2" + mkdir -p "$(dirname "$metadata")" + : > "$(dirname "$metadata")/$apk_name" + jq -n --arg output "$apk_name" \ + '{elements: [{type: "SINGLE", filters: [], outputFile: $output}]}' > "$metadata" +} + +analyzer="$(make_analyzer)" +target_meta="$TMP/target/output-metadata.json" +app_test_meta="$TMP/app-test/output-metadata.json" +baseline_test_meta="$TMP/baseline-test/output-metadata.json" +wrong_target_package_meta="$TMP/wrong-target-package/output-metadata.json" +wrong_runner_meta="$TMP/wrong-runner/output-metadata.json" +build_started="$(date +%s)" +write_metadata "$target_meta" target.apk +write_metadata "$app_test_meta" app-test.apk +write_metadata "$baseline_test_meta" baseline-test.apk +write_metadata "$wrong_target_package_meta" wrong-target-package.apk +write_metadata "$wrong_runner_meta" wrong-runner.apk + +mkdir -p "$TMP/no-tools" +missing_analyzer_output="$TMP/missing-analyzer.txt" +if env -u APKANALYZER \ + ANDROID_HOME="$TMP/missing-android-home" \ + PATH="$TMP/no-tools" \ + /bin/bash "$RESOLVER" >"$missing_analyzer_output" 2>&1; then + fail "missing apkanalyzer was accepted" +else + missing_analyzer_status=$? +fi +[[ "$missing_analyzer_status" -eq 1 ]] || + fail "missing apkanalyzer exited with $missing_analyzer_status instead of 1" +[[ "$(cat "$missing_analyzer_output")" == \ + "resolve-android-test-apk-pair: apkanalyzer is not available" ]] || + fail "missing apkanalyzer diagnostic was not bounded" + +valid_app="$(env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$target_meta" --test-metadata "$app_test_meta" \ + --built-after "$build_started")" || fail "valid app pair rejected" +[[ "$(jq -r .pairing_contract <<<"$valid_app")" == "app-android-test" ]] || + fail "app contract missing from output" + +valid_baseline="$(env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract standalone-self-target \ + --expected-target-application-id com.kino.puber.instrumentation \ + --expected-test-application-id com.kino.puber.baselineprofile \ + --target-metadata "$target_meta" --test-metadata "$baseline_test_meta" \ + --built-after "$build_started")" || fail "valid standalone pair rejected" +[[ "$(jq -r .test.target_package <<<"$valid_baseline")" == "com.kino.puber.baselineprofile" ]] || + fail "standalone target package missing" + +zero="$TMP/zero.json" +jq '.elements = []' "$target_meta" > "$zero" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$zero" --test-metadata "$app_test_meta" --built-after "$build_started" + +multi="$TMP/multi.json" +jq '.elements += [{type: "SINGLE", filters: [], outputFile: "other.apk"}]' "$target_meta" > "$multi" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$multi" --test-metadata "$app_test_meta" --built-after "$build_started" + +stale="$TMP/stale.json" +cp "$target_meta" "$stale" +touch -t 202001010000 "$stale" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$stale" --test-metadata "$app_test_meta" --built-after "$build_started" + +split="$TMP/split.json" +jq '.elements[0].type = "SPLIT"' "$target_meta" > "$split" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$split" --test-metadata "$app_test_meta" --built-after "$build_started" + +escape="$TMP/escape.json" +jq '.elements[0].outputFile = "../target.apk"' "$target_meta" > "$escape" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$escape" --test-metadata "$app_test_meta" --built-after "$build_started" + +metadata_link="$TMP/metadata-link.json" +ln -s "$target_meta" "$metadata_link" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$metadata_link" --test-metadata "$app_test_meta" --built-after "$build_started" + +stale_apk="$TMP/target/stale-apk.json" +cp "$target_meta" "$stale_apk" +touch -t 202001010000 "$TMP/target/target.apk" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$stale_apk" --test-metadata "$app_test_meta" --built-after "$build_started" +touch "$TMP/target/target.apk" + +apk_link="$TMP/target/apk-link.json" +jq '.elements[0].outputFile = "linked.apk"' "$target_meta" > "$apk_link" +ln -s target.apk "$TMP/target/linked.apk" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$apk_link" --test-metadata "$app_test_meta" --built-after "$build_started" + +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$target_meta" --test-metadata "$wrong_target_package_meta" --built-after "$build_started" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract app-android-test \ + --target-metadata "$target_meta" --test-metadata "$wrong_runner_meta" --built-after "$build_started" + +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract standalone-self-target \ + --expected-target-application-id com.kino.puber.instrumentation \ + --expected-test-application-id com.kino.puber.baselineprofile \ + --target-metadata "$target_meta" --test-metadata "$app_test_meta" --built-after "$build_started" +assert_rejected env APKANALYZER="$analyzer" "$RESOLVER" --pairing-contract standalone-self-target \ + --expected-target-application-id com.example.wrong \ + --expected-test-application-id com.kino.puber.baselineprofile \ + --target-metadata "$target_meta" --test-metadata "$baseline_test_meta" --built-after "$build_started" + +echo "APK pair resolver tests passed" From 634d0016b1686d6f3f7f1a6cfdda149d529d5c74 Mon Sep 17 00:00:00 2001 From: max rovkin Date: Tue, 1 Sep 2026 13:04:58 +0500 Subject: [PATCH 2/3] Add hermetic video player test coverage --- app/build.gradle.kts | 4 + .../player/PlayerInstrumentationTestCase.kt | 48 ++++ .../player/component/PlayerComposeScreen.kt | 48 ++++ .../component/PlayerScreenContentFocusTest.kt | 27 ++- .../player/component/PlayerScreenE2ETest.kt | 48 ++-- .../component/PlayerVideoSurfaceTest.kt | 3 +- .../player/vm/PlaybackControllerDeviceTest.kt | 3 +- .../vm/PlaybackControllerNetworkTracksTest.kt | 3 +- .../vm/PlaybackControllerResourcesTest.kt | 3 +- .../player/component/PlayerButtonRow.kt | 5 +- .../player/component/PlayerProgressBar.kt | 2 + .../player/component/PlayerScreenContent.kt | 10 + docs/testing/player-playback.md | 209 +++++++----------- gradle/libs.versions.toml | 7 + player-test-fixtures/SHA256SUMS | 20 -- tools/generate-player-test-fixtures.sh | 1 - 16 files changed, 257 insertions(+), 184 deletions(-) create mode 100644 app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt create mode 100644 app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt delete mode 100644 player-test-fixtures/SHA256SUMS diff --git a/app/build.gradle.kts b/app/build.gradle.kts index b34fa568..e4dcac75 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -313,8 +313,12 @@ dependencies { androidTestImplementation(platform(libs.androidx.compose.bom)) androidTestImplementation(libs.androidx.ui.test.junit4) androidTestImplementation(libs.mockwebserver3) + androidTestImplementation(libs.kaspresso) + androidTestImplementation(libs.kaspresso.compose) + androidTestImplementation(libs.kakao.compose) add("instrumentationImplementation", project(":player-test-fixtures")) add("instrumentationImplementation", libs.mockwebserver3) + add("instrumentationImplementation", libs.androidx.drawerlayout) debugImplementation(libs.androidx.ui.tooling) debugImplementation(libs.androidx.ui.test.manifest) diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt new file mode 100644 index 00000000..68b5bcf4 --- /dev/null +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt @@ -0,0 +1,48 @@ +package com.kino.puber.ui.feature.player + +import androidx.compose.ui.test.SemanticsNodeInteractionsProvider +import com.kaspersky.kaspresso.kaspresso.Kaspresso +import com.kaspersky.kaspresso.testcases.api.testcase.TestCase +import com.kino.puber.ui.feature.player.component.PlayerComposeScreen +import io.github.kakaocup.compose.node.element.ComposeScreen +import org.junit.Rule +import org.junit.rules.TestRule +import org.junit.runners.model.Statement + +internal abstract class PlayerInstrumentationTestCase : TestCase( + kaspressoBuilder = Kaspresso.Builder.simple(), +) { + + @get:Rule(order = 1) + val namedStepRule: TestRule = TestRule { statement, description -> + object : Statement() { + override fun evaluate() { + this@PlayerInstrumentationTestCase.run(testName = description.displayName) { + step(description.methodName.toPlayerStepName()) { + statement.evaluate() + } + } + } + } + } + + protected fun onPlayerScreen( + semanticsProvider: SemanticsNodeInteractionsProvider, + actions: PlayerComposeScreen.() -> Unit, + ) { + ComposeScreen.onComposeScreen( + semanticsProvider = semanticsProvider, + function = actions, + ) + } +} + +private fun String?.toPlayerStepName(): String { + return this + ?.replace('_', ' ') + ?.replace(CAMEL_CASE_BOUNDARY, " ") + ?.replaceFirstChar(Char::uppercase) + ?: "Run player instrumentation scenario" +} + +private val CAMEL_CASE_BOUNDARY = Regex("(?<=[a-z0-9])(?=[A-Z])") diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt new file mode 100644 index 00000000..b8f33d39 --- /dev/null +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt @@ -0,0 +1,48 @@ +package com.kino.puber.ui.feature.player.component + +import androidx.compose.ui.test.SemanticsNodeInteractionsProvider +import androidx.compose.ui.test.hasAnyDescendant +import androidx.compose.ui.test.hasText +import androidx.compose.ui.test.isFocused +import io.github.kakaocup.compose.node.element.ComposeScreen +import io.github.kakaocup.compose.node.element.KNode + +internal class PlayerComposeScreen( + semanticsProvider: SemanticsNodeInteractionsProvider, +) : ComposeScreen( + semanticsProvider = semanticsProvider, + viewBuilderAction = { + useUnmergedTree = true + hasTestTag(PlayerScreenTestTags.Root) + }, +) { + + val playerSurface: KNode = child { + useUnmergedTree = true + hasTestTag(PlayerScreenTestTags.Surface) + } + + val playPauseButton: KNode = child { + useUnmergedTree = true + hasTestTag(PlayerScreenTestTags.PlayPause) + } + + val seekBar: KNode = child { + useUnmergedTree = true + hasTestTag(PlayerScreenTestTags.SeekBar) + } + + fun text(text: String, substring: Boolean = false): KNode = child { + useUnmergedTree = true + hasText(text, substring = substring) + } + + fun focusedText(text: String, substring: Boolean = false): KNode { + val textMatcher = hasText(text, substring = substring) + val matcher = isFocused() and (textMatcher or hasAnyDescendant(textMatcher)) + return child { + useUnmergedTree = true + addSemanticsMatcher(matcher) + } + } +} diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt index f4a24829..3d72d055 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt @@ -40,6 +40,7 @@ import com.kino.puber.ui.feature.player.model.ResumeDialogState import com.kino.puber.ui.feature.player.model.SoundModeUIState import com.kino.puber.ui.feature.player.model.SpeedUIState import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState +import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase import com.kino.puber.ui.feature.player.vm.ControlsStateMachine import com.kino.puber.ui.feature.player.vm.PlaybackIntent import org.junit.Assert.assertEquals @@ -56,7 +57,7 @@ private const val QUALITY_ITEM = "1080p" private const val EPISODE_ITEM = "1. ŠŸŠµŃ€Š²Š¾Šµ Š²ŠŗŠ»ŃŽŃ‡ŠµŠ½ŠøŠµ" private const val MARK_WATCHED_BUTTON = "ŠŸŃ€Š¾ŃŠ¼Š¾Ń‚Ń€ŠµŠ½Š¾" -internal class PlayerScreenContentFocusTest { +internal class PlayerScreenContentFocusTest : PlayerInstrumentationTestCase() { @get:Rule val composeRule = createAndroidComposeRule() @@ -433,7 +434,9 @@ internal class PlayerScreenContentFocusTest { repeat(steps) { sendKey(KeyEvent.KEYCODE_DPAD_RIGHT) } - composeRule.onNodeWithText(text).assertIsFocused() + onPlayerScreen(composeRule) { + focusedText(text).assertIsFocused() + } } private fun assertFocusSurvivesRecomposition( @@ -457,6 +460,10 @@ internal class PlayerScreenContentFocusTest { } private fun assertFocusedPlayerSurface() { + onPlayerScreen(composeRule) { + playerSurface.assertIsDisplayed() + playerSurface.assertIsFocused() + } val focusedNode = focusedNode() val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot assertTrue( @@ -470,6 +477,10 @@ internal class PlayerScreenContentFocusTest { } private fun assertFocusedSeekBar() { + onPlayerScreen(composeRule) { + seekBar.assertIsDisplayed() + seekBar.assertIsFocused() + } val focusedNode = focusedNode() val rootWidth = composeRule.onRoot().fetchSemanticsNode().boundsInRoot.width assertTrue( @@ -483,6 +494,10 @@ internal class PlayerScreenContentFocusTest { } private fun assertFocusedControl() { + onPlayerScreen(composeRule) { + playPauseButton.assertIsDisplayed() + playPauseButton.assertIsFocused() + } waitUntilFocusedTarget { node -> val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot node.boundsInRoot.width < rootBounds.width * 0.5f && @@ -550,12 +565,16 @@ internal class PlayerScreenContentFocusTest { .getOrNull(SemanticsProperties.Focused) == true }.getOrDefault(false) } - composeRule.onNodeWithText(text).assertIsFocused() + onPlayerScreen(composeRule) { + focusedText(text).assertIsFocused() + } } private fun assertControlsVisible(harness: PlayerHarness) { assertTrue(harness.content.controlsVisible) - composeRule.onNodeWithText(AUDIO_BUTTON).assertIsDisplayed() + onPlayerScreen(composeRule) { + text(AUDIO_BUTTON).assertIsDisplayed() + } } private fun waitForControlsToBeDisposed() { diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt index ceb9a805..7fb2f61f 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt @@ -8,7 +8,6 @@ import androidx.activity.ComponentActivity import androidx.activity.compose.setContent import androidx.compose.runtime.Composable import androidx.compose.ui.semantics.SemanticsNode -import androidx.compose.ui.semantics.SemanticsActions import androidx.compose.ui.semantics.SemanticsProperties import androidx.compose.ui.semantics.getOrNull import androidx.compose.ui.test.SemanticsMatcher @@ -16,6 +15,7 @@ import androidx.compose.ui.test.assertIsDisplayed import androidx.compose.ui.test.assertIsFocused import androidx.compose.ui.test.getUnclippedBoundsInRoot import androidx.compose.ui.test.hasAnyDescendant +import androidx.compose.ui.test.hasTestTag import androidx.compose.ui.test.hasText import androidx.compose.ui.test.isFocused import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule @@ -48,6 +48,7 @@ import com.kino.puber.playertestfixtures.server.QueryMatchMode import com.kino.puber.playertestfixtures.server.ResponsePlan import com.kino.puber.profile.PlayerTestControl import com.kino.puber.ui.ScreensImpl +import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase import com.kino.puber.ui.feature.player.model.PlayerScreenParams import com.kino.puber.ui.feature.player.model.PlayerStartMode import java.util.UUID @@ -77,7 +78,7 @@ import org.koin.dsl.module */ @OptIn(UnstableApi::class) @RunWith(AndroidJUnit4::class) -internal class PlayerScreenE2ETest { +internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { @get:Rule val composeRule = createAndroidComposeRule() @@ -645,11 +646,25 @@ internal class PlayerScreenE2ETest { } private fun assertFocusedPlayPause() { - assertSingleFocusedNode(FOCUSED_UNLABELED_CLICKABLE, "play/pause button") + onPlayerScreen(composeRule) { + playPauseButton.assertIsDisplayed() + playPauseButton.assertIsFocused() + } + assertSingleFocusedNode( + isFocused() and hasTestTag(PlayerScreenTestTags.PlayPause), + "play/pause button", + ) } private fun assertFocusedSeekBar() { - val interaction = assertSingleFocusedNode(FOCUSED_NON_CLICKABLE, "seek bar") + onPlayerScreen(composeRule) { + seekBar.assertIsDisplayed() + seekBar.assertIsFocused() + } + val interaction = assertSingleFocusedNode( + isFocused() and hasTestTag(PlayerScreenTestTags.SeekBar), + "seek bar", + ) val rootBounds = composeRule.onRoot().getUnclippedBoundsInRoot() val focusedBounds = interaction.getUnclippedBoundsInRoot() val focusedHeight = (focusedBounds.bottom - focusedBounds.top).value @@ -665,6 +680,10 @@ internal class PlayerScreenE2ETest { private fun assertFocusedPlayerSurface() { awaitAbsent(context.getString(R.string.player_button_audio_subtitles)) + onPlayerScreen(composeRule) { + playerSurface.assertIsDisplayed() + playerSurface.assertIsFocused() + } val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot try { composeRule.waitUntil(FOCUS_TIMEOUT_MS) { @@ -698,6 +717,10 @@ internal class PlayerScreenE2ETest { text: String, substring: Boolean = false, ) { + onPlayerScreen(composeRule) { + focusedText(text, substring).assertIsDisplayed() + focusedText(text, substring).assertIsFocused() + } assertSingleFocusedNode(focusedTextMatcher(text, substring), "control '$text'") } @@ -1142,18 +1165,6 @@ internal class PlayerScreenE2ETest { const val EPISODE_ONE_ID_OFFSET = 11 const val EPISODE_TWO_ID_OFFSET = 12 - val FOCUSED_UNLABELED_CLICKABLE = - SemanticsMatcher("focused clickable control without text") { node -> - node.config.getOrNull(SemanticsProperties.Focused) == true && - node.config.contains(SemanticsActions.OnClick) && - !node.hasTextInSubtree() - } - - val FOCUSED_NON_CLICKABLE = - SemanticsMatcher("focused non-clickable control") { node -> - node.config.getOrNull(SemanticsProperties.Focused) == true && - !node.config.contains(SemanticsActions.OnClick) - } } } @@ -1167,11 +1178,6 @@ private data object PlayerE2EHostScreen : PuberScreen { } } -private fun SemanticsNode.hasTextInSubtree(): Boolean { - if (!config.getOrNull(SemanticsProperties.Text).isNullOrEmpty()) return true - return children.any(SemanticsNode::hasTextInSubtree) -} - private fun View.findPlayerView(): PlayerView? { if (this is PlayerView) return this if (this !is ViewGroup) return null diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt index 8ba52001..7f156750 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt @@ -9,6 +9,7 @@ import androidx.media3.exoplayer.ExoPlayer import androidx.media3.ui.PlayerView import androidx.tv.material3.MaterialTheme import com.kino.puber.domain.model.SubtitleSize +import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase import com.kino.puber.ui.feature.player.model.ActivePanel import com.kino.puber.ui.feature.player.model.PlayerContentState import com.kino.puber.ui.feature.player.vm.PlaybackIntent @@ -22,7 +23,7 @@ import org.junit.Assert.assertTrue import org.junit.Rule import org.junit.Test -internal class PlayerVideoSurfaceTest { +internal class PlayerVideoSurfaceTest : PlayerInstrumentationTestCase() { @get:Rule val composeRule = createAndroidComposeRule() diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt index bddde4fd..5689f878 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt @@ -23,6 +23,7 @@ import com.kino.puber.playertestfixtures.server.HermeticTestServer import com.kino.puber.playertestfixtures.server.ResponseOutcome import com.kino.puber.playertestfixtures.server.ResponsePlan import com.kino.puber.profile.PlayerTestControl +import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase import com.kino.puber.ui.feature.player.model.BufferPreset import java.io.File import java.util.UUID @@ -41,7 +42,7 @@ import org.junit.runner.RunWith @OptIn(UnstableApi::class) @RunWith(AndroidJUnit4::class) -internal class PlaybackControllerDeviceTest { +internal class PlaybackControllerDeviceTest : PlayerInstrumentationTestCase() { private val context get() = InstrumentationRegistry.getInstrumentation().targetContext diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt index 25f48d76..18e05597 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt @@ -29,6 +29,7 @@ import com.kino.puber.playertestfixtures.server.QueryMatchMode import com.kino.puber.playertestfixtures.server.ResponseOutcome import com.kino.puber.playertestfixtures.server.ResponsePlan import com.kino.puber.profile.PlayerTestControl +import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase import com.kino.puber.ui.feature.player.model.AudioTrackUIState import com.kino.puber.ui.feature.player.model.BufferPreset import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState @@ -49,7 +50,7 @@ import org.junit.runner.RunWith @OptIn(UnstableApi::class) @RunWith(AndroidJUnit4::class) -internal class PlaybackControllerNetworkTracksTest { +internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCase() { private val context get() = InstrumentationRegistry.getInstrumentation().targetContext diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt index 04ab479a..d838c2b5 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt @@ -27,6 +27,7 @@ import com.kino.puber.playertestfixtures.server.HermeticRoute import com.kino.puber.playertestfixtures.server.HermeticTestServer import com.kino.puber.playertestfixtures.server.ResponsePlan import com.kino.puber.profile.PlayerTestControl +import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase import com.kino.puber.ui.feature.player.model.AudioTrackUIState import com.kino.puber.ui.feature.player.model.BufferPreset import java.io.File @@ -50,7 +51,7 @@ import org.junit.runner.RunWith @OptIn(UnstableApi::class) @RunWith(AndroidJUnit4::class) -internal class PlaybackControllerResourcesTest { +internal class PlaybackControllerResourcesTest : PlayerInstrumentationTestCase() { private val context get() = InstrumentationRegistry.getInstrumentation().targetContext diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt index b04b3ca3..47b360a6 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt @@ -23,6 +23,7 @@ import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource import androidx.compose.ui.semantics.selected import androidx.compose.ui.semantics.semantics @@ -134,7 +135,9 @@ private fun PlayPauseButton( ) { Button( onClick = onClick, - modifier = Modifier.focusRequester(focusRequester), + modifier = Modifier + .testTag(PlayerScreenTestTags.PlayPause) + .focusRequester(focusRequester), colors = transparentButtonColors(), ) { Icon( diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt index b3361364..378485e8 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerProgressBar.kt @@ -35,6 +35,7 @@ import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.geometry.Offset import androidx.compose.ui.graphics.Brush import androidx.compose.ui.input.key.onKeyEvent +import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource import androidx.compose.ui.unit.dp import androidx.tv.material3.MaterialTheme @@ -178,6 +179,7 @@ private fun SeekTrack( Box( modifier = modifier .height(TRACK_TOUCH_HEIGHT) + .testTag(PlayerScreenTestTags.SeekBar) .then( downFocusRequester?.let { target -> Modifier.focusProperties { down = target } diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt index d70449ef..db079d82 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt @@ -20,6 +20,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.input.key.onKeyEvent +import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource import androidx.compose.ui.unit.dp import androidx.media3.exoplayer.ExoPlayer @@ -77,6 +78,7 @@ internal fun PlayerScreenContent( Box( modifier = modifier .fillMaxSize() + .testTag(PlayerScreenTestTags.Root) .background(MaterialTheme.colorScheme.scrim), ) { when (state) { @@ -214,6 +216,7 @@ private fun PlayerFocusAnchor( Box( modifier = Modifier .fillMaxSize() + .testTag(PlayerScreenTestTags.Surface) .focusRequester(focusRequester) .focusable(enabled = isFocusOwner) .then( @@ -231,6 +234,13 @@ private fun PlayerFocusAnchor( ) } +internal object PlayerScreenTestTags { + const val Root = "player_screen" + const val Surface = "player_surface" + const val PlayPause = "player_play_pause" + const val SeekBar = "player_seek_bar" +} + private fun handlePlayerKeyEvent( keyEvent: KeyEvent, onAction: (UIAction) -> Unit, diff --git a/docs/testing/player-playback.md b/docs/testing/player-playback.md index c85371bc..a1887d31 100644 --- a/docs/testing/player-playback.md +++ b/docs/testing/player-playback.md @@ -12,7 +12,7 @@ stream. | Fixture integrity | `:player-test-fixtures:test` and its Android test | The same committed bytes, metadata, playlist references, rendition labels, and WebVTT cue are available to JVM and Android tests. | | Host policy/state | `:app:testDevDebugUnitTest` and `:app:testProdDebugUnitTest`, filtered to `com.kino.puber.ui.feature.player.vm.*` | HLS error policy, subtitle MIME and identity, audio/subtitle preference matching, AC3 fallback state, VM transitions, and generation guards. | | Real player instrumentation | `PlaybackControllerDeviceTest`, `PlaybackControllerNetworkTracksTest`, and `PlaybackControllerResourcesTest` | The production `PlaybackController` and Media3 player load loopback MP4/HLS, render on a real `PlayerView`, select tracks/cues, recover from programmed faults, and release cleanly. | -| Production-screen instrumentation | `PlayerScreenE2ETest` | The production screen/Koin scope handles real media, D-pad/media/back events, lifecycle progress saves, resume, and series episode identity. | +| Production-screen instrumentation | `PlayerScreenContentFocusTest`, `PlayerScreenE2ETest`, and `PlayerVideoSurfaceTest` | The production screen/Koin scope handles real media, concrete TV focus, D-pad/media/back events, lifecycle progress saves, resume, series episode identity, and surface ownership. | The instrumentation tests use a per-test `SimpleCache`, unique scenario identities, event/latch/player fences instead of `Thread.sleep`, and bounded @@ -20,6 +20,13 @@ failure diagnostics. Teardown waits for zero active server requests, releases the player and surface, removes only test-owned cache state, and fails on unknown or external-origin requests. +All six player instrumentation classes share +`PlayerInstrumentationTestCase`, so each JUnit scenario is reported as a named +Kaspresso step. Production `PlayerScreen` journeys use `PlayerComposeScreen` +and the minimal stable player-only test tags. Controller, Media3, network, +cache, lifecycle, codec, request-journal, and resource assertions remain +direct and event-based inside those steps. + ## Fixture pack and provenance The single source of truth is @@ -34,9 +41,10 @@ The single source of truth is Expected metadata is in `player-test-fixtures/src/main/assets/player-fixtures/fixture-manifest.properties`. The complete byte manifest is -`player-test-fixtures/SHA256SUMS` (and the packaged copy under the fixture -asset directory). Generation details and synthetic-input provenance are in -`player-test-fixtures/fixtures-provenance.md`. +`player-test-fixtures/src/main/assets/player-fixtures/SHA256SUMS`. This +packaged manifest is also the JVM and Android runtime verification source; +there is no second generated copy. Generation details and synthetic-input +provenance are in `player-test-fixtures/fixtures-provenance.md`. Regeneration is a maintainer-only action. It requires `ffmpeg 9.0.1`, uses only `lavfi` test-pattern and sine-wave inputs, and is deliberately not part @@ -72,102 +80,64 @@ violation. Unknown routes and unexpected egress fail teardown. Authorization values, credentials, redirect query data, authenticated payloads, broad UI dumps, and raw logs are not test evidence. -## Host commands - -Run the deterministic fixture and resolver checks first: - -```sh -./tools/agentw :player-test-fixtures:test -./tools/test-resolve-android-test-apk-pair -``` - -Run the player host suites for both app flavors: - -```sh -./tools/agentw :app:testDevDebugUnitTest \ - --tests 'com.kino.puber.ui.feature.player.vm.*' -./tools/agentw :app:testProdDebugUnitTest \ - --tests 'com.kino.puber.ui.feature.player.vm.*' -``` - -Run compilation checks: - -```sh -./tools/agentw :app:compileDevDebugKotlin -./tools/agentw :app:compileInstrumentationDebugAndroidTestKotlin -``` - -## TV emulator execution - -Use a leased TV emulator only. Discover a running TV emulator, acquire its -exact serial lock, export `ANDROID_SERIAL`, and keep release in a trap: - -```sh -EMULATORS=($( - .kent/adapters/mobile/emulator-resource-lock.sh adb-emulators tv -)) -LOCK_OUTPUT="$( - .kent/adapters/mobile/emulator-resource-lock.sh \ - acquire-any "${EMULATORS[@]}" -- 900 7200 -)" -LOCK_RESOURCE="$(printf '%s\n' "$LOCK_OUTPUT" | sed -n 's/^resource=//p')" -LOCK_TOKEN="$(printf '%s\n' "$LOCK_OUTPUT" | sed -n 's/^token=//p')" -export ANDROID_SERIAL="$LOCK_RESOURCE" -trap '.kent/adapters/mobile/emulator-resource-lock.sh release \ - "$LOCK_RESOURCE" "$LOCK_TOKEN"' EXIT -test -n "$ANDROID_SERIAL" -``` - -If no suitable running emulator is available, stop rather than starting one -implicitly. Physical devices require separate explicit authorization. - -Build a fresh app instrumentation target and Android-test APK with -`--rerun-tasks`; do not use `connected*`, `install*`, or another Gradle task -that implicitly selects a device: - -```sh -BUILD_STARTED_AT="$(date +%s)" -./tools/agentw :app:assembleInstrumentationDebug \ - :app:assembleInstrumentationDebugAndroidTest --rerun-tasks -PAIR_JSON="$( - ./tools/resolve-android-test-apk-pair \ - --pairing-contract app-android-test \ - --target-metadata \ - app/build/outputs/apk/instrumentation/debug/output-metadata.json \ - --test-metadata \ - app/build/outputs/apk/androidTest/instrumentation/debug/output-metadata.json \ - --built-after "$BUILD_STARTED_AT" -)" -APP_APK="$(jq -r '.target.apk_path' <<<"$PAIR_JSON")" -APP_TEST_APK="$(jq -r '.test.apk_path' <<<"$PAIR_JSON")" -APP_PACKAGE="$(jq -r '.target.application_id' <<<"$PAIR_JSON")" -APP_TEST_PACKAGE="$(jq -r '.test.application_id' <<<"$PAIR_JSON")" -.kent/adapters/mobile/android-apk-install-preserve install-preserve \ - --serial "$ANDROID_SERIAL" --package "$APP_PACKAGE" --apk "$APP_APK" -.kent/adapters/mobile/android-apk-install-preserve install-preserve \ - --serial "$ANDROID_SERIAL" --package "$APP_TEST_PACKAGE" --apk "$APP_TEST_APK" -``` - -Run the complete player instrumentation suite with an explicit serial and -runner. During development, use one class filter at a time: - -```sh -adb -s "$ANDROID_SERIAL" shell am instrument -w -r \ - -e package com.kino.puber.ui.feature.player \ - "$APP_TEST_PACKAGE/androidx.test.runner.AndroidJUnitRunner" -``` - -The final acceptance run repeats this command twice from clean -test-owned state. It does not clear app data, uninstall packages, or use -flaky retry as a condition of success. The resolver output is the authority -for APK paths, package IDs, instrumentation target package, runner, and -SHA-256 values. - -The migrated PUB-77 baseline regression uses the separate -`standalone-self-target` resolver contract and is documented with its -explicit build/install/instrumentation commands in the task plan and -`02-server-contract.md`; it must not be paired with the app -`app-android-test` contract. +## Verification entry points + +The player-owned host entry points are: + +- fixture tests: `:player-test-fixtures:test`; +- APK-pair resolver regression: + `tools/test-resolve-android-test-apk-pair`; +- player VM suites: `:app:testDevDebugUnitTest` and + `:app:testProdDebugUnitTest`, filtered to + `com.kino.puber.ui.feature.player.vm.*`; +- production and Android-test compilation: + `:app:compileDevDebugKotlin` and + `:app:compileInstrumentationDebugAndroidTestKotlin`. + +Repository checkout and worktree command selection is owned by `AGENTS.md`; +this guide intentionally lists Gradle targets rather than duplicating wrapper +procedures. + +## APK pair validation + +`tools/resolve-android-test-apk-pair` and its executable regression suite, +`tools/test-resolve-android-test-apk-pair`, are project-owned. Keep them with +the variants and manifests whose pairing rules they enforce. + +Kent's runtime procedure validates and installs supplied APKs but does not +choose a target/test pair or prove that both APKs belong to the current build. +Before the runtime procedure begins, the resolver therefore: + +- requires both variant metadata files and both resolved APKs to be at least + as new as the caller's build-start timestamp; +- accepts exactly one regular, non-symlink, unfiltered `SINGLE` APK from each + metadata file; +- reads the APK manifests and requires + `androidx.test.runner.AndroidJUnitRunner`; +- requires the instrumentation `targetPackage` to match the selected pairing + contract; +- emits the validated paths, application IDs, target package, runner, and + SHA-256 values as one bounded JSON object. + +The self-test must remain beside the resolver because it fail-closes stale, +ambiguous, split, path-escaping, symlinked, wrong-runner, wrong-package, and +cross-contract pairs without requiring an emulator. + +## Device acceptance contract + +The complete package +`com.kino.puber.ui.feature.player` runs against a fresh +`app-android-test` resolver-validated target/test APK pair. Final acceptance +requires two clean passes without flaky retry. Each pass preserves the +hermetic network, concrete focus, track selection, lifecycle/restoration, +cache/resource cleanup, codec, request-journal, and production-data-safety +oracles described above. Resolver output remains the authority for APK paths, +package IDs, instrumentation target package, runner, and SHA-256 values. + +Kent owns emulator leasing, exact-serial targeting, preservation-safe +installation, runtime cleanup, and evidence capture. Follow +`.kent/context/smoke.md` and `.kent/commands/smoke-test.md`; those procedures +are intentionally not copied into this product guide. ## Emulator capabilities and diagnostics @@ -195,36 +165,9 @@ The fixture module is test-only. `:app` references it through `implementation`, `prodImplementation`, or runtime edge may resolve `:player-test-fixtures`. -Run the dependency and packaging checks: - -```sh -./tools/agentw :app:dependencies \ - --configuration prodReleaseRuntimeClasspath -./tools/agentw :app:assembleProdDebug -./tools/agentw :app:assembleProdRelease -./tools/agentw :app:bundleProdRelease -``` - -Inspect only bounded listings and fail if production artifacts contain the -fixture prefix, fixture hashes/provenance, test-control components, or server -packages: - -```sh -PROD_APK=app/build/outputs/apk/prod/release/app-prod-release.apk -PROD_AAB="$(printf '%s\n' app/build/outputs/bundle/prodRelease/*.aab)" -if unzip -l "$PROD_APK" | grep -Eq \ - 'player-fixtures|fixtures-provenance|playertestfixtures|TestControl'; then - echo "test-only player content found in production APK" >&2 - exit 1 -fi -if unzip -l "$PROD_AAB" | grep -Eq \ - 'player-fixtures|fixtures-provenance|playertestfixtures|TestControl'; then - echo "test-only player content found in production AAB" >&2 - exit 1 -fi -``` - -The production runtime dependency report must likewise contain no -`project :player-test-fixtures`. If release signing credentials are absent in -a local worktree, report that package-signing limitation explicitly; never -copy credentials into the worktree or weaken the production exclusion check. +Verification covers `prodReleaseRuntimeClasspath`, the prod debug/release APKs, +and the prod release AAB. Bounded artifact listings must contain no fixture +prefix, fixture hashes/provenance, test-control component, server package, +Kaspresso, or Kakao dependency. If release signing credentials are absent in a +local worktree, report that packaging limitation; never copy credentials into +the worktree or weaken the production exclusion check. diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 5e290143..6d53b9ee 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -33,6 +33,9 @@ profileinstaller = "1.4.1" uiautomator = "2.3.0" androidxTestExtJunit = "1.3.0" androidxTestRunner = "1.7.0" +kaspresso = "1.6.1" +kakaoCompose = "1.1.0" +drawerLayout = "1.1.1" [plugins] @@ -128,3 +131,7 @@ androidx-profileinstaller = { group = "androidx.profileinstaller", name = "profi androidx-uiautomator = { group = "androidx.test.uiautomator", name = "uiautomator", version.ref = "uiautomator" } androidx-test-ext-junit = { group = "androidx.test.ext", name = "junit", version.ref = "androidxTestExtJunit" } androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "androidxTestRunner" } +kaspresso = { group = "com.kaspersky.android-components", name = "kaspresso", version.ref = "kaspresso" } +kaspresso-compose = { group = "com.kaspersky.android-components", name = "kaspresso-compose-support", version.ref = "kaspresso" } +kakao-compose = { group = "io.github.kakaocup", name = "compose", version.ref = "kakaoCompose" } +androidx-drawerlayout = { group = "androidx.drawerlayout", name = "drawerlayout", version.ref = "drawerLayout" } diff --git a/player-test-fixtures/SHA256SUMS b/player-test-fixtures/SHA256SUMS deleted file mode 100644 index efedaf33..00000000 --- a/player-test-fixtures/SHA256SUMS +++ /dev/null @@ -1,20 +0,0 @@ -# Generated by tools/generate-player-test-fixtures.sh -# Paths are relative to player-test-fixtures/src/main/assets/player-fixtures -be066640856b0bafbe89b98ffb9d8242aef9dd80755e81632845acd2c6859592 fixture-manifest.properties -d0b66ca1cd5cf07f1653e6d186c9aa2bf98c12ae3411684d5a9d4990f0faac24 hls/audio_english_000.ts -f2835f530d2b5a429beca76edaec079e4ab7678523f8f895d97af287efc77ebb hls/audio_english_001.ts -0b4a3635ca144ac737dfbabd915a35906a8198c6d986381ed59ff0075223588a hls/audio_english_002.ts -638546fcf88de892ebf4c35abba3b96a87a1e8288db6e6c8e0213102ba74546b hls/audio_english.m3u8 -f4258109fb94de22cde3e6bcef2d063253d86fd1439c455101257ee2a26295a6 hls/audio_spanish_000.ts -5d031767863b8894f788ea6c55d9fb368b2197634e23c2e1bb6d788eb5279eb0 hls/audio_spanish_001.ts -e0c4b54aa29660c8730a21ffd6725d728ac9299cbfd582e483ad08aded6113b6 hls/audio_spanish_002.ts -57628e73ee5e3813ad203033f8d5d7bc729d32d70bd3a9756c1cfa1adaf7a40d hls/audio_spanish.m3u8 -f49ce7e56a295611d77085ce6dda7e9d4232738d9e69f140f3e72362bc82413a hls/master.m3u8 -2886e10d3a695dbe1fc76c2e5990794602c0c3f75b6f875dd834f0c6fac9e919 hls/video_360_000.ts -584395ec46703e2c377dacaf7c25f4da282037c1097ab6cf500db76ea950858d hls/video_360_001.ts -23b1ecbd66d278f3d75082204ab380e234bf7dd876391b5a5bd84c597c81103d hls/video_360.m3u8 -39b126ca12647e3819b9c353c9a7e0ee97a6f41c270ae8bfd2370bcc690e30ea hls/video_720_000.ts -a625ffd32332483b7b090d7f5c599634c131056fcffbd492a5d2ba7667b24ece hls/video_720_001.ts -db1893295cd255c902a33580a1149779255965ffef2afd66d224e975a77e9cc8 hls/video_720.m3u8 -66e3482994223b65cc915d37218558051216a6668e8b6429102efc35a27ee796 progressive.mp4 -aa39ae5106857d2e539299d0ce5d552ce8f5f96c1594f954c7c8a0eed69729e6 subtitle.vtt diff --git a/tools/generate-player-test-fixtures.sh b/tools/generate-player-test-fixtures.sh index 8d005cbe..c4eca9d1 100755 --- a/tools/generate-player-test-fixtures.sh +++ b/tools/generate-player-test-fixtures.sh @@ -195,6 +195,5 @@ hash_for() { printf '%s %s\n' "$(hash_for "$path")" "$path" done } > "$output/SHA256SUMS" -cp "$output/SHA256SUMS" "$MODULE_ROOT/SHA256SUMS" echo "Generated fixture pack at $output" From a190406bd277169d4991a5349baa8f2f93294e6d Mon Sep 17 00:00:00 2001 From: max rovkin Date: Tue, 1 Sep 2026 20:15:19 +0500 Subject: [PATCH 3/3] Refine player Kaspresso test delivery --- .../player/PlayerInstrumentationTestCase.kt | 32 +- .../player/component/PlayerComposeScreen.kt | 40 + .../component/PlayerScreenContentFocusTest.kt | 755 ++++++------- .../player/component/PlayerScreenE2ETest.kt | 999 ++++++++++-------- .../feature/player/component/PlayerTvRobot.kt | 223 ++++ .../component/PlayerVideoSurfaceTest.kt | 266 ++--- .../player/vm/PlaybackControllerDeviceTest.kt | 217 ++-- .../vm/PlaybackControllerNetworkTracksTest.kt | 673 +++++++----- .../vm/PlaybackControllerResourcesTest.kt | 383 ++++--- .../player/component/AudioSubtitlesPanel.kt | 3 + .../player/component/NextEpisodeOverlay.kt | 5 +- .../player/component/PlayerButtonRow.kt | 13 +- .../player/component/PlayerScreenContent.kt | 13 +- .../feature/player/component/ResumeDialog.kt | 5 +- .../player/component/SettingsPanelColumn.kt | 8 +- .../player/component/VideoSettingsPanel.kt | 4 + docs/testing/player-playback.md | 22 +- .../PlayerTestFixturesAndroidTest.kt | 12 +- .../playertestfixtures/PlayerTestFixtures.kt | 45 +- .../PlayerTestFixturesTest.kt | 24 + 20 files changed, 2169 insertions(+), 1573 deletions(-) create mode 100644 app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerTvRobot.kt diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt index 68b5bcf4..31f2f2b5 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/PlayerInstrumentationTestCase.kt @@ -1,31 +1,19 @@ package com.kino.puber.ui.feature.player import androidx.compose.ui.test.SemanticsNodeInteractionsProvider +import com.kaspersky.components.composesupport.config.withComposeSupport import com.kaspersky.kaspresso.kaspresso.Kaspresso import com.kaspersky.kaspresso.testcases.api.testcase.TestCase import com.kino.puber.ui.feature.player.component.PlayerComposeScreen import io.github.kakaocup.compose.node.element.ComposeScreen -import org.junit.Rule -import org.junit.rules.TestRule -import org.junit.runners.model.Statement internal abstract class PlayerInstrumentationTestCase : TestCase( kaspressoBuilder = Kaspresso.Builder.simple(), -) { - - @get:Rule(order = 1) - val namedStepRule: TestRule = TestRule { statement, description -> - object : Statement() { - override fun evaluate() { - this@PlayerInstrumentationTestCase.run(testName = description.displayName) { - step(description.methodName.toPlayerStepName()) { - statement.evaluate() - } - } - } - } - } +) +internal abstract class PlayerComposeInstrumentationTestCase : TestCase( + kaspressoBuilder = Kaspresso.Builder.withComposeSupport(), +) { protected fun onPlayerScreen( semanticsProvider: SemanticsNodeInteractionsProvider, actions: PlayerComposeScreen.() -> Unit, @@ -36,13 +24,3 @@ internal abstract class PlayerInstrumentationTestCase : TestCase( ) } } - -private fun String?.toPlayerStepName(): String { - return this - ?.replace('_', ' ') - ?.replace(CAMEL_CASE_BOUNDARY, " ") - ?.replaceFirstChar(Char::uppercase) - ?: "Run player instrumentation scenario" -} - -private val CAMEL_CASE_BOUNDARY = Regex("(?<=[a-z0-9])(?=[A-Z])") diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt index b8f33d39..d36963b9 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerComposeScreen.kt @@ -2,6 +2,7 @@ package com.kino.puber.ui.feature.player.component import androidx.compose.ui.test.SemanticsNodeInteractionsProvider import androidx.compose.ui.test.hasAnyDescendant +import androidx.compose.ui.test.hasTestTag import androidx.compose.ui.test.hasText import androidx.compose.ui.test.isFocused import io.github.kakaocup.compose.node.element.ComposeScreen @@ -32,6 +33,45 @@ internal class PlayerComposeScreen( hasTestTag(PlayerScreenTestTags.SeekBar) } + val markWatchedButton: KNode = tagged(PlayerScreenTestTags.MarkWatched) + val episodesButton: KNode = tagged(PlayerScreenTestTags.Episodes) + val audioSubtitlesButton: KNode = tagged(PlayerScreenTestTags.AudioSubtitles) + val videoSettingsButton: KNode = tagged(PlayerScreenTestTags.VideoSettings) + val resumeButton: KNode = tagged(PlayerScreenTestTags.ResumeContinue) + val retryButton: KNode = tagged(PlayerScreenTestTags.Retry) + val nextEpisodeButton: KNode = tagged(PlayerScreenTestTags.NextEpisode) + + val focusedMarkWatchedButton: KNode = focusedTag(PlayerScreenTestTags.MarkWatched) + val focusedEpisodesButton: KNode = focusedTag(PlayerScreenTestTags.Episodes) + val focusedAudioSubtitlesButton: KNode = focusedTag(PlayerScreenTestTags.AudioSubtitles) + val focusedVideoSettingsButton: KNode = focusedTag(PlayerScreenTestTags.VideoSettings) + val focusedResumeButton: KNode = focusedTag(PlayerScreenTestTags.ResumeContinue) + val focusedRetryButton: KNode = focusedTag(PlayerScreenTestTags.Retry) + val focusedNextEpisodeButton: KNode = focusedTag(PlayerScreenTestTags.NextEpisode) + + fun panelItem(group: String, index: Int): KNode = + tagged(PlayerScreenTestTags.panelItem(group, index)) + + fun focusedPanelItem(group: String, index: Int): KNode = + focusedTag(PlayerScreenTestTags.panelItem(group, index)) + + fun tagged(tag: String): KNode = child { + useUnmergedTree = true + hasTestTag(tag) + } + + fun focusedTag(tag: String): KNode { + val tagMatcher = hasTestTag(tag) + val matcher = isFocused() and ( + tagMatcher or + hasAnyDescendant(tagMatcher) + ) + return child { + useUnmergedTree = true + addSemanticsMatcher(matcher) + } + } + fun text(text: String, substring: Boolean = false): KNode = child { useUnmergedTree = true hasText(text, substring = substring) diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt index 3d72d055..30135997 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt @@ -1,26 +1,15 @@ package com.kino.puber.ui.feature.player.component -import android.view.KeyEvent import androidx.activity.ComponentActivity import androidx.activity.OnBackPressedCallback import androidx.compose.runtime.MutableState import androidx.compose.runtime.mutableStateOf -import androidx.compose.ui.semantics.SemanticsProperties -import androidx.compose.ui.semantics.getOrNull -import androidx.compose.ui.test.assertIsDisplayed import androidx.compose.ui.test.assertIsFocused import androidx.compose.ui.test.assertIsNotEnabled import androidx.compose.ui.test.assertIsNotFocused -import androidx.compose.ui.test.hasText -import androidx.compose.ui.test.isFocused -import androidx.compose.ui.test.isFocusable +import androidx.compose.ui.test.hasTestTag import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule -import androidx.compose.ui.test.onNodeWithText -import androidx.compose.ui.test.onParent -import androidx.compose.ui.test.onRoot -import androidx.compose.ui.test.performKeyInput import androidx.lifecycle.Lifecycle -import androidx.test.platform.app.InstrumentationRegistry import com.kino.puber.core.ui.uikit.component.moviesList.VideoGridItemUIState import com.kino.puber.core.ui.uikit.component.moviesList.VideoGridUIState import com.kino.puber.core.ui.uikit.component.moviesList.VideoItemUIState @@ -40,7 +29,7 @@ import com.kino.puber.ui.feature.player.model.ResumeDialogState import com.kino.puber.ui.feature.player.model.SoundModeUIState import com.kino.puber.ui.feature.player.model.SpeedUIState import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState -import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase +import com.kino.puber.ui.feature.player.PlayerComposeInstrumentationTestCase import com.kino.puber.ui.feature.player.vm.ControlsStateMachine import com.kino.puber.ui.feature.player.vm.PlaybackIntent import org.junit.Assert.assertEquals @@ -49,361 +38,444 @@ import org.junit.Assert.assertTrue import org.junit.Rule import org.junit.Test -private const val AUDIO_BUTTON = "ŠŃƒŠ“ŠøŠ¾ Šø суŠ±Ń‚Šøтры" -private const val VIDEO_BUTTON = "Š’ŠøŠ“ŠµŠ¾" -private const val EPISODES_BUTTON = "Š”ŠµŃ€ŠøŠø" -private const val SOUND_ITEM = "Š”тŠµŃ€ŠµŠ¾ 2.0" -private const val QUALITY_ITEM = "1080p" -private const val EPISODE_ITEM = "1. ŠŸŠµŃ€Š²Š¾Šµ Š²ŠŗŠ»ŃŽŃ‡ŠµŠ½ŠøŠµ" -private const val MARK_WATCHED_BUTTON = "ŠŸŃ€Š¾ŃŠ¼Š¾Ń‚Ń€ŠµŠ½Š¾" - -internal class PlayerScreenContentFocusTest : PlayerInstrumentationTestCase() { +internal class PlayerScreenContentFocusTest : PlayerComposeInstrumentationTestCase() { @get:Rule val composeRule = createAndroidComposeRule() + private val robot by lazy { PlayerTvRobot(composeRule) } + @Test - fun initialControlsBackMovesFocusToPlayer_andDpadDownReopensFirstButton() { + fun initialControlsBackMovesFocusToPlayer_andDpadDownReopensFirstButton() = run { val harness = render() - assertExactlyOneFocusedNode() - assertFocusedControl() - assertPlayerAnchorFocusable(expected = false) - assertFocusSurvivesRecomposition(harness, ::assertFocusedControl) - - sendKey(KeyEvent.KEYCODE_BACK) - waitForControlsToBeDisposed() - - assertEquals(0, harness.exitRequestCount) - assertExactlyOneFocusedNode() - assertFocusedPlayerSurface() - assertPlayerAnchorFocusable(expected = true) - assertHiddenControlsAreNotFocused() + step("Initial controls own the single focus target across recomposition") { + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + robot.focus.assertPlayerAnchorFocusable(expected = false) + harness.bumpPosition() + composeRule.waitForIdle() + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + } - sendKey(KeyEvent.KEYCODE_DPAD_DOWN) + step("Back hides controls and transfers focus to the player surface") { + robot.pressBack() + robot.waitForControlsToBeDisposed() + assertEquals(0, harness.exitRequestCount) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedPlayerSurface() + robot.focus.assertPlayerAnchorFocusable(expected = true) + robot.focus.assertHiddenControlsAreNotFocused() + } - assertExactlyOneFocusedNode() - assertFocusedControl() - assertControlsVisible(harness) + step("D-pad Down reopens controls on the first button") { + robot.press(PlayerRemoteKey.Down) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + robot.assertControlsVisible(harness.content.controlsVisible) + } } @Test - fun playerToControlsHandoff_keepsPlayerFocused_untilDelayedControlFocusSucceeds() { + fun playerToControlsHandoff_keepsPlayerFocused_untilDelayedControlFocusSucceeds() = run { val harness = render() hideControls(harness) composeRule.mainClock.autoAdvance = false try { - sendKeyWithoutSettling(KeyEvent.KEYCODE_DPAD_DOWN) - composeRule.mainClock.advanceTimeByFrame() - composeRule.waitForIdle() - - assertTrue(harness.content.controlsVisible) - assertExactlyOneFocusedNode() - assertFocusedPlayerSurface() - assertPlayerAnchorFocusable(expected = true) - - composeRule.mainClock.advanceTimeByFrame() - composeRule.waitForIdle() - - assertExactlyOneFocusedNode() - assertFocusedControl() - assertHiddenPlayerIsNotFocused() + step("D-pad Down reveals controls while the player retains focus") { + robot.pressWithoutSettling(PlayerRemoteKey.Down) + robot.advanceOneFrame() + assertTrue(harness.content.controlsVisible) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedPlayerSurface() + robot.focus.assertPlayerAnchorFocusable(expected = true) + } - composeRule.mainClock.advanceTimeByFrame() - composeRule.waitForIdle() + step("The delayed handoff focuses the first control") { + robot.advanceOneFrame() + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + robot.focus.assertHiddenPlayerIsNotFocused() + } - assertExactlyOneFocusedNode() - assertFocusedControl() - assertPlayerAnchorFocusable(expected = false) + step("The player anchor becomes non-focusable after handoff") { + robot.advanceOneFrame() + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + robot.focus.assertPlayerAnchorFocusable(expected = false) + } } finally { composeRule.mainClock.autoAdvance = true } } @Test - fun resumeDialogOwnsFocus_thenSelectionTransfersToPlayerAnchor() { + fun resumeDialogOwnsFocus_thenSelectionTransfersToPlayerAnchor() = run { val harness = render(content(resumeDialog = resumeDialog())) - composeRule.onNodeWithText("ŠŸŃ€Š¾Š“Š¾Š»Š¶Šøть").assertIsFocused() - assertExactlyOneFocusedNode() - assertPlayerAnchorFocusable(expected = false) - assertFocusSurvivesRecomposition(harness) { - composeRule.onNodeWithText("ŠŸŃ€Š¾Š“Š¾Š»Š¶Šøть").assertIsFocused() + step("The resume dialog owns focus across recomposition") { + robot.screen { + focusedResumeButton.assertIsFocused() + } + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertPlayerAnchorFocusable(expected = false) + harness.bumpPosition() + composeRule.waitForIdle() + robot.focus.assertExactlyOneFocusedNode() + robot.screen { + focusedResumeButton.assertIsFocused() + } } - composeRule.onNodeWithText("ŠŸŃ€Š¾Š“Š¾Š»Š¶Šøть").performKeyInput { - keyDown(androidx.compose.ui.input.key.Key.Enter) - keyUp(androidx.compose.ui.input.key.Key.Enter) + step("Selecting Continue transfers focus to the player anchor") { + robot.press(PlayerRemoteKey.Select) + assertTrue(harness.content.resumeDialog == null) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedPlayerSurface() + robot.focus.assertPlayerAnchorFocusable(expected = true) } - composeRule.waitForIdle() - - assertTrue(harness.content.resumeDialog == null) - assertExactlyOneFocusedNode() - assertFocusedPlayerSurface() - assertPlayerAnchorFocusable(expected = true) } @Test - fun hiddenPlayer_dpadUpReopensSeekBar_andDpadDownReopensButtons() { + fun hiddenPlayer_dpadUpReopensSeekBar_andDpadDownReopensButtons() = run { val harness = render() hideControls(harness) - sendKey(KeyEvent.KEYCODE_DPAD_UP) - assertExactlyOneFocusedNode() - assertFocusedSeekBar() - assertEquals(listOf(FocusTarget.SeekBar), harness.revealedTargets) + step("D-pad Up reopens controls on the seek bar") { + robot.press(PlayerRemoteKey.Up) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedSeekBar() + assertEquals(listOf(FocusTarget.SeekBar), harness.revealedTargets) + } - hideControls(harness) - sendKey(KeyEvent.KEYCODE_DPAD_DOWN) - assertExactlyOneFocusedNode() - assertFocusedControl() - assertEquals( - listOf(FocusTarget.SeekBar, FocusTarget.Buttons), - harness.revealedTargets, - ) + step("D-pad Down reopens controls on the first button") { + hideControls(harness) + robot.press(PlayerRemoteKey.Down) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + assertEquals( + listOf(FocusTarget.SeekBar, FocusTarget.Buttons), + harness.revealedTargets, + ) + } } @Test - fun hiddenPlayer_directionalSeekPerformsOneAction_andFocusesSeekBar() { + fun hiddenPlayer_directionalSeekPerformsOneAction_andFocusesSeekBar() = run { val harness = render() hideControls(harness) - sendKey(KeyEvent.KEYCODE_DPAD_LEFT) - assertExactlyOneFocusedNode() - assertFocusedSeekBar() - assertEquals(1, harness.seekBackwardCount) - assertEquals(0, harness.seekForwardCount) - assertEquals(listOf(FocusTarget.SeekBar), harness.revealedTargets) + step("D-pad Left performs one backward seek and focuses the seek bar") { + robot.press(PlayerRemoteKey.Left) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedSeekBar() + assertEquals(1, harness.seekBackwardCount) + assertEquals(0, harness.seekForwardCount) + assertEquals(listOf(FocusTarget.SeekBar), harness.revealedTargets) + } - hideControls(harness) - sendKey(KeyEvent.KEYCODE_DPAD_RIGHT) - assertExactlyOneFocusedNode() - assertFocusedSeekBar() - assertEquals(1, harness.seekBackwardCount) - assertEquals(1, harness.seekForwardCount) - assertEquals( - listOf(FocusTarget.SeekBar, FocusTarget.SeekBar), - harness.revealedTargets, - ) + step("D-pad Right performs one forward seek and preserves the seek target") { + hideControls(harness) + robot.press(PlayerRemoteKey.Right) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedSeekBar() + assertEquals(1, harness.seekBackwardCount) + assertEquals(1, harness.seekForwardCount) + assertEquals( + listOf(FocusTarget.SeekBar, FocusTarget.SeekBar), + harness.revealedTargets, + ) + } } @Test - fun hiddenPlayer_dpadCenterPerformsOnePlaybackAction_andFocusesFirstButton() { + fun hiddenPlayer_dpadCenterPerformsOnePlaybackAction_andFocusesFirstButton() = run { val harness = render() hideControls(harness) - sendKey(KeyEvent.KEYCODE_DPAD_CENTER) - - assertExactlyOneFocusedNode() - assertFocusedControl() - assertEquals(1, harness.togglePlayPauseCount) - assertEquals(listOf(FocusTarget.Buttons), harness.revealedTargets) + step("D-pad Center toggles playback once and focuses the first button") { + robot.press(PlayerRemoteKey.Select) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + assertEquals(1, harness.togglePlayPauseCount) + assertEquals(listOf(FocusTarget.Buttons), harness.revealedTargets) + } } @Test - fun hiddenPlayer_enterPerformsOnePlaybackAction_andFocusesFirstButton() { + fun hiddenPlayer_enterPerformsOnePlaybackAction_andFocusesFirstButton() = run { val harness = render() hideControls(harness) - sendKey(KeyEvent.KEYCODE_ENTER) - - assertExactlyOneFocusedNode() - assertFocusedControl() - assertEquals(1, harness.togglePlayPauseCount) - assertEquals(listOf(FocusTarget.Buttons), harness.revealedTargets) + step("Enter toggles playback once and focuses the first button") { + robot.press(PlayerRemoteKey.Enter) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + assertEquals(1, harness.togglePlayPauseCount) + assertEquals(listOf(FocusTarget.Buttons), harness.revealedTargets) + } } @Test - fun hiddenPlayer_mediaSeekAndPlaybackKeysPerformOneAction_andKeepTargetContract() { + fun hiddenPlayer_mediaSeekAndPlaybackKeysPerformOneAction_andKeepTargetContract() = run { val harness = render() - hideControls(harness) - sendKey(KeyEvent.KEYCODE_MEDIA_REWIND) - assertFocusedSeekBar() - assertEquals(1, harness.seekBackwardCount) - assertEquals(1, harness.revealedTargets.size) - assertEquals(FocusTarget.SeekBar, harness.revealedTargets.single()) - - hideControls(harness) - sendKey(KeyEvent.KEYCODE_MEDIA_FAST_FORWARD) - assertFocusedSeekBar() - assertEquals(1, harness.seekForwardCount) - - hideControls(harness) - sendKey(KeyEvent.KEYCODE_MEDIA_SKIP_BACKWARD) - assertFocusedSeekBar() - assertEquals(2, harness.seekBackwardCount) - - hideControls(harness) - sendKey(KeyEvent.KEYCODE_MEDIA_SKIP_FORWARD) - assertFocusedSeekBar() - assertEquals(2, harness.seekForwardCount) + step("Media rewind and fast-forward keys seek once and focus the seek bar") { + hideControls(harness) + robot.press(PlayerRemoteKey.Rewind) + robot.focus.assertFocusedSeekBar() + assertEquals(1, harness.seekBackwardCount) + assertEquals(1, harness.revealedTargets.size) + assertEquals(FocusTarget.SeekBar, harness.revealedTargets.single()) + + hideControls(harness) + robot.press(PlayerRemoteKey.FastForward) + robot.focus.assertFocusedSeekBar() + assertEquals(1, harness.seekForwardCount) + } - hideControls(harness) - sendKey(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - assertFocusedControl() - assertEquals(1, harness.togglePlayPauseCount) - assertEquals(FocusTarget.Buttons, harness.revealedTargets.last()) + step("Media skip keys preserve one seek action per key") { + hideControls(harness) + robot.press(PlayerRemoteKey.SkipBackward) + robot.focus.assertFocusedSeekBar() + assertEquals(2, harness.seekBackwardCount) - hideControls(harness) - sendKey(KeyEvent.KEYCODE_MEDIA_PLAY) - assertFocusedControl() - assertEquals(2, harness.togglePlayPauseCount) + hideControls(harness) + robot.press(PlayerRemoteKey.SkipForward) + robot.focus.assertFocusedSeekBar() + assertEquals(2, harness.seekForwardCount) + } - hideControls(harness) - sendKey(KeyEvent.KEYCODE_MEDIA_PAUSE) - assertFocusedControl() - assertEquals(3, harness.togglePlayPauseCount) + step("Media playback keys toggle once and focus the first button") { + hideControls(harness) + robot.press(PlayerRemoteKey.PlayPause) + robot.focus.assertFocusedControl() + assertEquals(1, harness.togglePlayPauseCount) + assertEquals(FocusTarget.Buttons, harness.revealedTargets.last()) + + hideControls(harness) + robot.press(PlayerRemoteKey.Play) + robot.focus.assertFocusedControl() + assertEquals(2, harness.togglePlayPauseCount) + + hideControls(harness) + robot.press(PlayerRemoteKey.Pause) + robot.focus.assertFocusedControl() + assertEquals(3, harness.togglePlayPauseCount) + } } @Test - fun controlsTraversal_opensAudioPanel_andBackRestoresAudioButton() { + fun controlsTraversal_opensAudioPanel_andBackRestoresAudioButton() = run { val harness = render() - focusButton(AUDIO_BUTTON, steps = 1) - sendKey(KeyEvent.KEYCODE_ENTER) - - composeRule.onNodeWithText(SOUND_ITEM).assertIsFocused() - assertExactlyOneFocusedNode() - assertPlayerAnchorFocusable(expected = false) - composeRule.onNodeWithText(AUDIO_BUTTON).assertDoesNotExist() - assertFocusSurvivesRecomposition(harness) { - composeRule.onNodeWithText(SOUND_ITEM).assertIsFocused() + step("D-pad traversal focuses and opens Audio and subtitles") { + robot.screen { + robot.focusButton(focusedAudioSubtitlesButton, dpadRightSteps = 1) + } + robot.press(PlayerRemoteKey.Enter) } - sendKey(KeyEvent.KEYCODE_BACK) + step("The sound item owns focus across recomposition") { + robot.screen { + focusedPanelItem("sound", 0).assertIsFocused() + audioSubtitlesButton.assertDoesNotExist() + } + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertPlayerAnchorFocusable(expected = false) + harness.bumpPosition() + composeRule.waitForIdle() + robot.focus.assertExactlyOneFocusedNode() + robot.screen { + focusedPanelItem("sound", 0).assertIsFocused() + } + } - assertExactlyOneFocusedNode() - waitUntilFocusedText(AUDIO_BUTTON) - assertEquals(ActivePanel.None, harness.content.activePanel) + step("Back closes the panel and restores Audio and subtitles focus") { + robot.pressBack() + robot.focus.assertExactlyOneFocusedNode() + robot.screen { + robot.waitUntilFocused(focusedAudioSubtitlesButton) + } + assertEquals(ActivePanel.None, harness.content.activePanel) + } } @Test - fun controlsTraversal_opensVideoPanel_andBackRestoresVideoButton() { + fun controlsTraversal_opensVideoPanel_andBackRestoresVideoButton() = run { val harness = render() - focusButton(VIDEO_BUTTON, steps = 2) - sendKey(KeyEvent.KEYCODE_ENTER) - - composeRule.onNodeWithText(QUALITY_ITEM).assertIsFocused() - assertExactlyOneFocusedNode() - assertPlayerAnchorFocusable(expected = false) + step("D-pad traversal focuses and opens Video settings") { + robot.screen { + robot.focusButton(focusedVideoSettingsButton, dpadRightSteps = 2) + } + robot.press(PlayerRemoteKey.Enter) + } - sendKey(KeyEvent.KEYCODE_BACK) + step("The selected quality owns the single panel focus target") { + robot.screen { + focusedPanelItem("quality", 0).assertIsFocused() + } + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertPlayerAnchorFocusable(expected = false) + } - assertExactlyOneFocusedNode() - waitUntilFocusedText(VIDEO_BUTTON) - assertEquals(ActivePanel.None, harness.content.activePanel) + step("Back closes the panel and restores Video settings focus") { + robot.pressBack() + robot.focus.assertExactlyOneFocusedNode() + robot.screen { + robot.waitUntilFocused(focusedVideoSettingsButton) + } + assertEquals(ActivePanel.None, harness.content.activePanel) + } } @Test - fun seriesEpisodesPanel_focusesCurrentEpisode_andBackRestoresEpisodesButton() { + fun seriesEpisodesPanel_focusesCurrentEpisode_andBackRestoresEpisodesButton() = run { val harness = render(content(isMovie = false)) - focusButton(EPISODES_BUTTON, steps = 1) - sendKey(KeyEvent.KEYCODE_ENTER) - - composeRule.onNodeWithText(EPISODE_ITEM).assertIsFocused() - assertExactlyOneFocusedNode() - assertPlayerAnchorFocusable(expected = false) + step("D-pad traversal focuses and opens Episodes") { + robot.screen { + robot.focusButton(focusedEpisodesButton, dpadRightSteps = 1) + } + robot.press(PlayerRemoteKey.Enter) + } - sendKey(KeyEvent.KEYCODE_BACK) + step("The current episode model owns the single panel focus target") { + robot.screen { + focusedText(currentEpisodeTitle(harness.content)).assertIsFocused() + } + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertPlayerAnchorFocusable(expected = false) + } - assertExactlyOneFocusedNode() - waitUntilFocusedText(EPISODES_BUTTON) - assertEquals(ActivePanel.None, harness.content.activePanel) + step("Back closes the panel and restores Episodes focus") { + robot.pressBack() + robot.focus.assertExactlyOneFocusedNode() + robot.screen { + robot.waitUntilFocused(focusedEpisodesButton) + } + assertEquals(ActivePanel.None, harness.content.activePanel) + } } @Test - fun controlsTraversal_movesFromSeekBarToButtonRow_withOneFocusedNode() { + fun controlsTraversal_movesFromSeekBarToButtonRow_withOneFocusedNode() = run { val harness = render() hideControls(harness) - sendKey(KeyEvent.KEYCODE_DPAD_UP) - assertFocusedSeekBar() + step("D-pad Up reopens controls with seek-bar focus") { + robot.press(PlayerRemoteKey.Up) + robot.focus.assertFocusedSeekBar() + } - sendKey(KeyEvent.KEYCODE_DPAD_DOWN) - assertExactlyOneFocusedNode() - assertFocusedControl() - assertTrue(harness.content.controlsVisible) + step("D-pad Down moves from the seek bar to the first button") { + robot.press(PlayerRemoteKey.Down) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + assertTrue(harness.content.controlsVisible) + } } @Test - fun playbackEndedReveal_focusesFirstButton_andPlayerAnchorLosesFocus() { + fun playbackEndedReveal_focusesFirstButton_andPlayerAnchorLosesFocus() = run { val harness = render(content(isMovie = false)) hideControls(harness) - harness.revealControls(FocusTarget.Buttons) - - assertExactlyOneFocusedNode() - assertFocusedControl() - assertHiddenPlayerIsNotFocused() - assertEquals(FocusTarget.Buttons, harness.content.controlsFocusTarget) + step("Playback-ended reveal focuses the first button") { + harness.revealControls(FocusTarget.Buttons) + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + robot.focus.assertHiddenPlayerIsNotFocused() + assertEquals(FocusTarget.Buttons, harness.content.controlsFocusTarget) + } } @Test - fun hiddenDisabledExitingAndDetachedControls_neverOwnFocus() { + fun hiddenDisabledExitingAndDetachedControls_neverOwnFocus() = run { val harness = render( content( canMarkCurrentWatched = true, isMarkCurrentWatchedInFlight = true, ), ) - val disabledControl = composeRule - .onNodeWithText(MARK_WATCHED_BUTTON, useUnmergedTree = true) - .onParent() - .onParent() - - disabledControl.assertIsNotEnabled() - disabledControl.assertIsNotFocused() - assertExactlyOneFocusedNode() - assertFocusedControl() + val disabledControl = composeRule.onNode( + hasTestTag(PlayerScreenTestTags.MarkWatched), + useUnmergedTree = true, + ) composeRule.mainClock.autoAdvance = false - composeRule.runOnIdle { - harness.onAction(PlayerAction.HideControls) - } - composeRule.mainClock.advanceTimeBy(FOCUS_TRANSFER_SETTLE_MS) - composeRule.waitForIdle() - - assertFalse(harness.content.controlsVisible) - composeRule.onNodeWithText(AUDIO_BUTTON).assertExists().assertIsNotFocused() - disabledControl.assertExists().assertIsNotEnabled().assertIsNotFocused() - assertExactlyOneFocusedNode() - assertFocusedPlayerSurface() + try { + step("A disabled control never owns initial focus") { + disabledControl.assertIsNotEnabled() + disabledControl.assertIsNotFocused() + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedControl() + } - composeRule.mainClock.advanceTimeBy(CONTROLS_EXIT_SETTLE_MS) - composeRule.waitForIdle() + step("Exiting controls transfer focus to the player before disposal") { + composeRule.runOnIdle { + harness.onAction(PlayerAction.HideControls) + } + robot.advanceClockBy(FOCUS_TRANSFER_SETTLE_MS) + assertFalse(harness.content.controlsVisible) + robot.screen { + audioSubtitlesButton.assertExists() + focusedAudioSubtitlesButton.assertDoesNotExist() + } + disabledControl.assertExists().assertIsNotEnabled().assertIsNotFocused() + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedPlayerSurface() + } - composeRule.onNodeWithText(AUDIO_BUTTON).assertDoesNotExist() - composeRule.onNodeWithText(MARK_WATCHED_BUTTON).assertDoesNotExist() - assertExactlyOneFocusedNode() - assertFocusedPlayerSurface() - composeRule.mainClock.autoAdvance = true + step("Detached controls disappear without stealing player focus") { + robot.advanceClockBy(CONTROLS_EXIT_SETTLE_MS) + robot.screen { + audioSubtitlesButton.assertDoesNotExist() + markWatchedButton.assertDoesNotExist() + } + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedPlayerSurface() + } + } finally { + composeRule.mainClock.autoAdvance = true + } } @Test - fun hiddenSecondBack_exitsOnce_andRecompositionKeepsPlayerFocus() { + fun hiddenSecondBack_exitsOnce_andRecompositionKeepsPlayerFocus() = run { val harness = render() hideControls(harness) - assertFocusedPlayerSurface() - assertFocusSurvivesRecomposition(harness, ::assertFocusedPlayerSurface) + step("The hidden player keeps focus across recomposition") { + robot.focus.assertFocusedPlayerSurface() + harness.bumpPosition() + composeRule.waitForIdle() + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedPlayerSurface() + } - sendKey(KeyEvent.KEYCODE_BACK) - assertEquals(1, harness.exitRequestCount) - assertExactlyOneFocusedNode() + step("The second Back exits exactly once") { + robot.pressBack() + assertEquals(1, harness.exitRequestCount) + robot.focus.assertExactlyOneFocusedNode() + } - composeRule.activityRule.scenario.moveToState(Lifecycle.State.CREATED) - composeRule.activityRule.scenario.moveToState(Lifecycle.State.RESUMED) - composeRule.waitForIdle() - assertExactlyOneFocusedNode() - assertFocusedPlayerSurface() + step("Lifecycle resume restores the single player focus owner") { + composeRule.activityRule.scenario.moveToState(Lifecycle.State.CREATED) + composeRule.activityRule.scenario.moveToState(Lifecycle.State.RESUMED) + composeRule.waitForIdle() + robot.focus.assertExactlyOneFocusedNode() + robot.focus.assertFocusedPlayerSurface() + } - sendKey(KeyEvent.KEYCODE_DPAD_DOWN) - assertFocusedControl() - assertEquals(FocusTarget.Buttons, harness.revealedTargets.last()) + step("D-pad Down after resume reopens the first button") { + robot.press(PlayerRemoteKey.Down) + robot.focus.assertFocusedControl() + assertEquals(FocusTarget.Buttons, harness.revealedTargets.last()) + } } private fun render( @@ -427,174 +499,7 @@ internal class PlayerScreenContentFocusTest : PlayerInstrumentationTestCase() { private fun hideControls(harness: PlayerHarness) { harness.onAction(PlayerAction.HideControls) composeRule.waitForIdle() - assertFocusedPlayerSurface() - } - - private fun focusButton(text: String, steps: Int) { - repeat(steps) { - sendKey(KeyEvent.KEYCODE_DPAD_RIGHT) - } - onPlayerScreen(composeRule) { - focusedText(text).assertIsFocused() - } - } - - private fun assertFocusSurvivesRecomposition( - harness: PlayerHarness, - assertFocusedOwner: () -> Unit, - ) { - harness.bumpPosition() - composeRule.waitForIdle() - assertExactlyOneFocusedNode() - assertFocusedOwner() - } - - private fun assertExactlyOneFocusedNode() { - assertEquals( - "PlayerScreen must have exactly one focused semantics node", - 1, - composeRule.onAllNodes(isFocused(), useUnmergedTree = true) - .fetchSemanticsNodes() - .size, - ) - } - - private fun assertFocusedPlayerSurface() { - onPlayerScreen(composeRule) { - playerSurface.assertIsDisplayed() - playerSurface.assertIsFocused() - } - val focusedNode = focusedNode() - val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot - assertTrue( - "Focused player anchor must cover the root width", - focusedNode.boundsInRoot.width >= rootBounds.width * 0.9f, - ) - assertTrue( - "Focused player anchor must cover the root height", - focusedNode.boundsInRoot.height >= rootBounds.height * 0.9f, - ) - } - - private fun assertFocusedSeekBar() { - onPlayerScreen(composeRule) { - seekBar.assertIsDisplayed() - seekBar.assertIsFocused() - } - val focusedNode = focusedNode() - val rootWidth = composeRule.onRoot().fetchSemanticsNode().boundsInRoot.width - assertTrue( - "Seek bar must be the focused wide control: node=${focusedNode.boundsInRoot}, root=$rootWidth", - focusedNode.boundsInRoot.width >= rootWidth * 0.5f, - ) - assertTrue( - "Seek bar must not be the full-screen player anchor: node=${focusedNode.boundsInRoot}, root=$rootWidth", - focusedNode.boundsInRoot.width < rootWidth * 0.9f, - ) - } - - private fun assertFocusedControl() { - onPlayerScreen(composeRule) { - playPauseButton.assertIsDisplayed() - playPauseButton.assertIsFocused() - } - waitUntilFocusedTarget { node -> - val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot - node.boundsInRoot.width < rootBounds.width * 0.5f && - node.boundsInRoot.height < rootBounds.height * 0.9f - } - val focusedNode = focusedNode() - val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot - assertTrue( - "Control focus must not remain on the full-screen player anchor", - focusedNode.boundsInRoot.width < rootBounds.width * 0.5f && - focusedNode.boundsInRoot.height < rootBounds.height * 0.9f, - ) - } - - private fun assertHiddenControlsAreNotFocused() { - composeRule.onNodeWithText(AUDIO_BUTTON).assertDoesNotExist() - composeRule.onNodeWithText(VIDEO_BUTTON).assertDoesNotExist() - } - - private fun assertHiddenPlayerIsNotFocused() { - val focusedNode = focusedNode() - val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot - assertFalse( - "Player anchor must lose focus after controls reopen", - focusedNode.boundsInRoot.width >= rootBounds.width * 0.9f, - ) - } - - private fun assertPlayerAnchorFocusable(expected: Boolean) { - val rootBounds = composeRule.onRoot().fetchSemanticsNode().boundsInRoot - val fullScreenFocusableCount = composeRule - .onAllNodes(isFocusable(), useUnmergedTree = true) - .fetchSemanticsNodes() - .count { node -> - node.boundsInRoot.width >= rootBounds.width * 0.9f && - node.boundsInRoot.height >= rootBounds.height * 0.9f - } - assertEquals( - "Only the typed Player owner may expose the full-screen focus anchor", - if (expected) 1 else 0, - fullScreenFocusableCount, - ) - } - - private fun focusedNode() = composeRule - .onAllNodes(isFocused(), useUnmergedTree = true) - .fetchSemanticsNodes() - .single() - - private fun waitUntilFocusedTarget(predicate: (androidx.compose.ui.semantics.SemanticsNode) -> Boolean) { - composeRule.waitUntil(timeoutMillis = 5_000) { - composeRule.onAllNodes(isFocused(), useUnmergedTree = true) - .fetchSemanticsNodes() - .singleOrNull() - ?.let(predicate) == true - } - } - - private fun waitUntilFocusedText(text: String) { - composeRule.waitUntil(timeoutMillis = 5_000) { - runCatching { - composeRule.onNodeWithText(text) - .fetchSemanticsNode() - .config - .getOrNull(SemanticsProperties.Focused) == true - }.getOrDefault(false) - } - onPlayerScreen(composeRule) { - focusedText(text).assertIsFocused() - } - } - - private fun assertControlsVisible(harness: PlayerHarness) { - assertTrue(harness.content.controlsVisible) - onPlayerScreen(composeRule) { - text(AUDIO_BUTTON).assertIsDisplayed() - } - } - - private fun waitForControlsToBeDisposed() { - composeRule.waitUntil(timeoutMillis = 5_000) { - composeRule.onAllNodes( - hasText(AUDIO_BUTTON), - useUnmergedTree = true, - ).fetchSemanticsNodes().isEmpty() - } - } - - private fun sendKey(keyCode: Int) { - sendKeyWithoutSettling(keyCode) - composeRule.waitForIdle() - } - - private fun sendKeyWithoutSettling(keyCode: Int) { - val instrumentation = InstrumentationRegistry.getInstrumentation() - instrumentation.sendKeySync(KeyEvent(KeyEvent.ACTION_DOWN, keyCode)) - instrumentation.sendKeySync(KeyEvent(KeyEvent.ACTION_UP, keyCode)) + robot.focus.assertFocusedPlayerSurface() } private fun content( @@ -622,10 +527,12 @@ internal class PlayerScreenContentFocusTest : PlayerInstrumentationTestCase() { selectedAudioTrackIndex = 0, subtitleTracks = listOf(SubtitleTrackUIState(0, "Š’Ń‹ŠŗŠ».", "", "")), selectedSubtitleIndex = 0, - soundModes = listOf(SoundModeUIState(0, SOUND_ITEM)), + soundModes = listOf(SoundModeUIState(0, FIXTURE_SOUND_MODE)), selectedSoundModeIndex = 0, subtitleSize = SubtitleSize.MEDIUM, - qualities = listOf(QualityUIState(0, QUALITY_ITEM, 1080, 1920, 1080)), + qualities = listOf( + QualityUIState(0, FIXTURE_QUALITY, 1080, 1920, 1080), + ), selectedQualityIndex = 0, speeds = listOf(SpeedUIState(0, "ŠŠ¾Ń€Š¼.", 1f)), selectedSpeedIndex = 0, @@ -652,7 +559,7 @@ internal class PlayerScreenContentFocusTest : PlayerInstrumentationTestCase() { items = listOf( VideoItemUIState( id = CURRENT_EPISODE_ID, - title = EPISODE_ITEM, + title = FIXTURE_EPISODE_TITLE, imageUrl = "", bigImageUrl = "", showTitle = true, @@ -671,6 +578,15 @@ internal class PlayerScreenContentFocusTest : PlayerInstrumentationTestCase() { episodeInfo = null, ) + private fun currentEpisodeTitle(content: PlayerContentState): String = + content.episodes + ?.list + ?.filterIsInstance() + ?.flatMap(VideoGridItemUIState.Items::items) + ?.single { it.id == content.currentEpisodeId } + ?.title + ?: error("Missing current episode model ${content.currentEpisodeId}") + private class PlayerHarness( initialContent: PlayerContentState, ) { @@ -772,6 +688,9 @@ internal class PlayerScreenContentFocusTest : PlayerInstrumentationTestCase() { private companion object { const val CURRENT_EPISODE_ID = 101 + const val FIXTURE_SOUND_MODE = "Fixture sound mode" + const val FIXTURE_QUALITY = "Fixture quality" + const val FIXTURE_EPISODE_TITLE = "Fixture episode" const val FOCUS_TRANSFER_SETTLE_MS = 64L const val CONTROLS_EXIT_SETTLE_MS = 1_000L } diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt index 7fb2f61f..a86355ed 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt @@ -3,7 +3,6 @@ package com.kino.puber.ui.feature.player.component import android.app.Activity import android.view.View import android.view.ViewGroup -import android.view.KeyEvent as AndroidKeyEvent import androidx.activity.ComponentActivity import androidx.activity.compose.setContent import androidx.compose.runtime.Composable @@ -16,7 +15,6 @@ import androidx.compose.ui.test.assertIsFocused import androidx.compose.ui.test.getUnclippedBoundsInRoot import androidx.compose.ui.test.hasAnyDescendant import androidx.compose.ui.test.hasTestTag -import androidx.compose.ui.test.hasText import androidx.compose.ui.test.isFocused import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule import androidx.compose.ui.test.onAllNodesWithText @@ -25,7 +23,6 @@ import androidx.compose.ui.test.onRoot import androidx.lifecycle.Lifecycle import androidx.media3.common.C import androidx.media3.common.Player -import androidx.media3.common.util.UnstableApi import androidx.media3.ui.PlayerView import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.platform.app.InstrumentationRegistry @@ -48,7 +45,7 @@ import com.kino.puber.playertestfixtures.server.QueryMatchMode import com.kino.puber.playertestfixtures.server.ResponsePlan import com.kino.puber.profile.PlayerTestControl import com.kino.puber.ui.ScreensImpl -import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase +import com.kino.puber.ui.feature.player.PlayerComposeInstrumentationTestCase import com.kino.puber.ui.feature.player.model.PlayerScreenParams import com.kino.puber.ui.feature.player.model.PlayerStartMode import java.util.UUID @@ -68,6 +65,7 @@ import org.junit.Before import org.junit.Rule import org.junit.Test import org.junit.runner.RunWith +import io.github.kakaocup.compose.node.element.ComposeScreen import org.koin.core.context.GlobalContext import org.koin.core.qualifier.named import org.koin.dsl.module @@ -76,28 +74,488 @@ import org.koin.dsl.module * Production-screen coverage. Every case launches the real [PlayerScreen] * through the same FlowComponent and screen Koin scope used by the app. */ -@OptIn(UnstableApi::class) @RunWith(AndroidJUnit4::class) -internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { +internal class PlayerScreenE2ETest : PlayerComposeInstrumentationTestCase() { @get:Rule val composeRule = createAndroidComposeRule() + private lateinit var fixture: PlayerE2EFixture + + @Before + fun setUp() { + fixture = PlayerE2EFixture(composeRule) + fixture.start() + } + + @After + fun tearDown() { + fixture.close() + } + + @Test + fun movieScreen_realRemoteControlsPanelsAndRecreation_restoreFocusTracksAndMediaState() = run { + with(fixture) { + val itemId = 7901 + val media = MovieMediaRoots(itemId) + step("Launch the production movie screen on typed hermetic HLS routes") { + server.reset(movieRoutes(itemId, watchingTime = 0, media = media)) + launchPlayer( + itemId = itemId, + startMode = PlayerStartMode.StartFromBeginning, + ) + assertFocusedPlayPause() + awaitPlayerReady() + awaitPlayerCondition("initial movie position advances") { + playerPosition() >= POSITION_FENCE_MS + } + } + + step("The domain TV remote toggles playback through the player focus anchor") { + robot.pressBack() + assertFocusedPlayerSurface() + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("media key pauses playback") { !playerIsPlaying() } + assertFocusedPlayPause() + robot.pressBack() + assertFocusedPlayerSurface() + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("media key resumes playback") { playerIsPlaying() } + assertFocusedPlayPause() + robot.pressBack() + assertFocusedPlayerSurface() + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("second media key pauses playback") { !playerIsPlaying() } + assertFocusedPlayPause() + } + + step("Seek-bar and button traversal retains one concrete focused node") { + robot.press(PlayerRemoteKey.Up) + assertFocusedSeekBar() + robot.press(PlayerRemoteKey.Down) + assertFocusedPlayPause() + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.MarkWatched, "mark-watched button") + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button") + } + + step("Select Spanish audio and external subtitles through typed panel items") { + robot.press(PlayerRemoteKey.Select) + assertFocusedPanelItem("sound", 0) + robot.press(PlayerRemoteKey.Right) + assertFocusedPanelItem("audio", 0) + robot.press(PlayerRemoteKey.Down) + assertFocusedPanelItem("audio", 1) + robot.press(PlayerRemoteKey.Select) + awaitPlayerCondition("Spanish audio is selected in UI state and Media3") { + selectedAudioLanguage() == SPANISH_LANGUAGE && + preferredAudioLanguage() == SPANISH_LANGUAGE + } + + robot.press(PlayerRemoteKey.Right) + assertFocusedPanelItem("subtitle", 1) + robot.press(PlayerRemoteKey.Select) + awaitPlayerCondition("external subtitle is persisted and selected in Media3") { + preferredSubtitleLanguage() == SUBTITLE_LANGUAGE && + selectedTextTrack() && + preferredTextLanguages().contains(SUBTITLE_LANGUAGE) + } + robot.pressBack() + assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button") + } + + step("Playback requests the selected subtitle before pausing again") { + robot.press(PlayerRemoteKey.Left) + assertFocusedTag(PlayerScreenTestTags.MarkWatched, "mark-watched button") + robot.press(PlayerRemoteKey.Left) + assertFocusedPlayPause() + robot.press(PlayerRemoteKey.Select) + awaitPlayerCondition("selected external subtitle loads during playback") { + playerIsPlaying() + } + awaitJournalPath("${media.high}/subtitle.vtt") + robot.press(PlayerRemoteKey.Select) + awaitPlayerCondition("playback pauses after external subtitle request") { + !playerIsPlaying() + } + } + + step("Switch to the lower quality and prove the production Media3 request") { + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.MarkWatched, "mark-watched button") + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button") + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.VideoSettings, "video-settings button") + robot.press(PlayerRemoteKey.Select) + assertFocusedPanelItem("quality", 0) + robot.press(PlayerRemoteKey.Down) + assertFocusedPanelItem("quality", 1) + robot.press(PlayerRemoteKey.Down) + assertFocusedPanelItem("quality", 2) + robot.press(PlayerRemoteKey.Select) + awaitPlayerCondition("manual quality changes the production Media3 item") { + currentMediaPath() == "${media.low}/master.m3u8" + } + awaitJournalPath("${media.low}/master.m3u8") + robot.pressBack() + assertFocusedTag(PlayerScreenTestTags.VideoSettings, "video-settings button") + robot.pressBack() + assertFocusedPlayerSurface() + robot.press(PlayerRemoteKey.Down) + assertFocusedPlayPause() + } + + step("Activity recreation restores production playback and selected tracks") { + val previousActivity = AtomicReference() + composeRule.activityRule.scenario.onActivity(previousActivity::set) + composeRule.activityRule.scenario.recreate() + setPlayerContent() + composeRule.activityRule.scenario.onActivity { recreatedActivity -> + assertTrue( + "ActivityScenario.recreate must replace the host activity", + recreatedActivity !== previousActivity.get(), + ) + } + assertFocusedPlayPause() + awaitPlayerReady() + awaitPlayerCondition("recreated UI state restores audio and subtitle choices") { + preferredAudioLanguage() == SPANISH_LANGUAGE && + preferredSubtitleLanguage() == SUBTITLE_LANGUAGE + } + awaitPlayerCondition("recreated Media3 restores audio and subtitle choices") { + selectedAudioLanguage() == SPANISH_LANGUAGE && + selectedTextTrack() && + preferredTextLanguages().contains(SUBTITLE_LANGUAGE) + } + } + + step("Recreated video and audio panels close on the current router and restore focus") { + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.MarkWatched, "mark-watched button") + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button") + robot.press(PlayerRemoteKey.Right) + assertFocusedTag(PlayerScreenTestTags.VideoSettings, "video-settings button") + robot.press(PlayerRemoteKey.Select) + assertFocusedPanelItem("quality", 0) + robot.pressBack() + assertFalse( + "Video-settings panel Back must not pop PlayerScreen after recreation", + isTextDisplayed(HOST_TEXT), + ) + assertFocusedTag(PlayerScreenTestTags.VideoSettings, "video-settings button") + + robot.press(PlayerRemoteKey.Left) + assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button") + robot.press(PlayerRemoteKey.Select) + assertFocusedPanelItem("sound", 0) + assertEquals(SPANISH_LANGUAGE, preferredAudioLanguage()) + assertEquals(SUBTITLE_LANGUAGE, preferredSubtitleLanguage()) + robot.pressBack() + assertFalse( + "Audio/subtitle panel Back must not pop PlayerScreen after recreation", + isTextDisplayed(HOST_TEXT), + ) + assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button") + } + + step("Recreated directional seeks preserve surface focus and fail-closed requests") { + robot.pressBack() + assertFocusedPlayerSurface() + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("recreated playback starts or replays before seek checks") { + playerIsPlaying() && playerPosition() >= POSITION_FENCE_MS + } + assertFocusedPlayPause() + robot.pressBack() + assertFocusedPlayerSurface() + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("recreated playback pauses from the player surface") { + !playerIsPlaying() && playerPosition() >= POSITION_FENCE_MS + } + assertFocusedPlayPause() + robot.pressBack() + assertFocusedPlayerSurface() + val beforeBackwardSeek = playerPosition() + robot.press(PlayerRemoteKey.Left) + awaitPlayerCondition("D-pad left seeks backward") { + playerPosition() < beforeBackwardSeek + } + awaitText( + context.getString( + R.string.player_seek_backward, + SEEK_STEP_SECONDS, + ), + ) + assertFocusedPlayerSurface() + val beforeForwardSeek = playerPosition() + robot.press(PlayerRemoteKey.Right) + awaitPlayerCondition("D-pad right seeks forward") { + playerPosition() > beforeForwardSeek + } + awaitText( + context.getString( + R.string.player_seek_forward, + SEEK_STEP_SECONDS, + ), + ) + assertFocusedPlayerSurface() + assertEquals(0, server.requestJournal.unknownRequests.size) + } + + step("The unchanged second Back exits the recreated PlayerScreen") { + robot.pressBack() + awaitPlayerCondition("recreated PlayerScreen exits on the unchanged second Back") { + isTextDisplayed(HOST_TEXT) + } + } + } + } + + @Test + fun movieScreen_continueCrossesSavedFence_andSeparatesPauseBackgroundAndExitSaves() = run { + with(fixture) { + val itemId = 7902 + val media = MovieMediaRoots(itemId) + step("Launch the saved movie and continue past its persisted position") { + server.reset( + movieRoutes( + itemId, + watchingTime = SAVED_POSITION_SECONDS, + media = media, + ), + ) + launchPlayer(itemId) + assertFocusedTag(PlayerScreenTestTags.ResumeContinue, "Continue button") + assertTrue(playerPosition() < SAVED_POSITION_FENCE_MS) + robot.press(PlayerRemoteKey.Select) + awaitPlayerCondition("Continue crosses the saved-position fence") { + playerPosition() >= SAVED_POSITION_FENCE_MS + } + assertFocusedPlayerSurface() + } + + lateinit var pauseSave: RecordedRequest + step("Pause creates a typed progress request after observable player state") { + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("pause is observable before its save") { + !playerIsPlaying() + } + assertFocusedPlayPause() + pauseSave = awaitProgressRequest( + "pause progress save", + itemId, + video = 1, + season = null, + ) + assertProgressTimeAtLeast(pauseSave, MIN_SAVED_TIME_SECONDS) + } + + lateinit var backgroundSave: RecordedRequest + step("Backgrounding creates a distinct progress request and keeps playback paused") { + robot.press(PlayerRemoteKey.Select) + awaitPlayerCondition("play resumes before background") { playerIsPlaying() } + composeRule.activityRule.scenario.moveToState(Lifecycle.State.CREATED) + backgroundSave = awaitProgressRequest( + "background progress save", + itemId, + video = 1, + season = null, + ) + assertProgressTimeAtLeast(backgroundSave, MIN_SAVED_TIME_SECONDS) + composeRule.activityRule.scenario.moveToState(Lifecycle.State.RESUMED) + setPlayerContentIfMissing() + awaitPlayerCondition("background keeps the player paused") { + !playerIsPlaying() + } + assertFocusedPlayerSurface() + } + + step("Exit drains its own progress request after the canonical second Back") { + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("play resumes before exit") { playerIsPlaying() } + assertFocusedPlayPause() + robot.pressBack() + assertFocusedPlayerSurface() + robot.pressBack() + val exitSave = awaitProgressRequest( + "exit progress save", + itemId, + video = 1, + season = null, + ) + assertProgressTimeAtLeast(exitSave, MIN_SAVED_TIME_SECONDS) + awaitPlayerCondition("Back exits only after the final progress write drains") { + isTextDisplayed(HOST_TEXT) + } + assertTrue(pauseSave !== backgroundSave) + assertTrue(backgroundSave !== exitSave) + } + } + } + + @Test + fun movieScreen_failedMedia_focusesRetry_recoversAndBackDrainsProgressBeforeExit() = run { + with(fixture) { + val itemId = 7903 + val media = MovieMediaRoots(itemId) + step("Launch the typed failing HLS route and focus the stable Retry control") { + server.reset(retryMovieRoutes(itemId, media)) + launchPlayer( + itemId = itemId, + startMode = PlayerStartMode.StartFromBeginning, + ) + assertFocusedPlayPause() + assertFocusedTagEventually(PlayerScreenTestTags.Retry, "Retry button") + assertEquals( + RETRY_FAILURE_REQUESTS, + routeRequestCount(media.high, "master"), + ) + } + + step("Retry reaches real playback after the programmed response sequence") { + robot.press(PlayerRemoteKey.Select) + awaitPlayerReady() + awaitPlayerCondition("Retry reaches real playback") { + playerIsPlaying() && + currentMediaPath() == "${media.high}/master.m3u8" + } + assertTrue( + routeRequestCount(media.high, "master") > RETRY_FAILURE_REQUESTS, + ) + assertFocusedPlayPause() + } + + step("Recovered playback drains progress before the canonical Back exit") { + robot.pressBack() + assertFocusedPlayerSurface() + robot.pressBack() + awaitProgressRequest( + "Retry journey exit save", + itemId, + video = 1, + season = null, + ) + awaitPlayerCondition("Back exits recovered playback") { + isTextDisplayed(HOST_TEXT) + } + } + } + } + + @Test + fun seriesScreen_nextEpisodeDpadJourney_usesDistinctRoutesAndEpisodeProgressIdentity() = run { + with(fixture) { + val itemId = 7904 + val media = SeriesMediaRoots(itemId) + step("Launch episode one and focus the stable next-episode action") { + server.reset(seriesRoutes(itemId, media)) + launchPlayer( + itemId = itemId, + seasonNumber = 1, + episodeNumber = 1, + startMode = PlayerStartMode.StartFromBeginning, + ) + assertFocusedPlayPause() + awaitPlayerReady() + awaitJournalPath("${media.episodeOne}/master.m3u8") + assertFocusedTagEventually( + PlayerScreenTestTags.NextEpisode, + "next-episode button", + ) + } + + lateinit var firstEpisodeSave: RecordedRequest + step("Selecting next episode saves episode one under its typed video identity") { + robot.press(PlayerRemoteKey.Select) + firstEpisodeSave = awaitProgressRequest( + "first episode transition save", + itemId, + video = 1, + season = 1, + ) + assertNull(firstEpisodeSave.url.queryParameter("episode")) + } + + step("Episode two owns the production player and a distinct media route") { + awaitJournalPath("${media.episodeTwo}/master.m3u8") + awaitPlayerCondition("second episode owns the active production player") { + currentMediaPath() == "${media.episodeTwo}/master.m3u8" + } + awaitText( + context.getString( + R.string.player_season_episode_title, + 1, + 2, + "Second episode", + ), + ) + awaitPlayerReady() + } + + step("Pausing episode two saves progress under video two and fails closed") { + if (isTagDisplayed(PlayerScreenTestTags.AudioSubtitles)) { + robot.pressBack() + } + assertFocusedPlayerSurface() + robot.press(PlayerRemoteKey.PlayPause) + awaitPlayerCondition("second episode pause is observable") { + !playerIsPlaying() + } + val secondEpisodeSave = awaitProgressRequest( + "second episode pause save", + itemId, + video = 2, + season = 1, + ) + assertNull(secondEpisodeSave.url.queryParameter("episode")) + assertTrue( + "Expected distinct episode media routes: " + + server.requestJournal.entries, + server.requestJournal.entries.any { + it.path == "${media.episodeOne}/master.m3u8" + } && server.requestJournal.entries.any { + it.path == "${media.episodeTwo}/master.m3u8" + }, + ) + assertEquals("1", firstEpisodeSave.url.queryParameter("video")) + assertEquals("2", secondEpisodeSave.url.queryParameter("video")) + assertEquals(0, server.requestJournal.unknownRequests.size) + } + } + } +} + +private class PlayerE2EFixture( + val composeRule: androidx.compose.ui.test.junit4.AndroidComposeTestRule< + androidx.test.ext.junit.rules.ActivityScenarioRule, + ComponentActivity, + >, +) { + private val instrumentation get() = InstrumentationRegistry.getInstrumentation() - private val context + val context get() = instrumentation.targetContext - private lateinit var server: PlayerTestControl + lateinit var server: PlayerTestControl + private set private lateinit var scenarioToken: String private lateinit var flowScopeName: String private lateinit var currentScreen: PlayerScreen private var currentItemId: Int = 0 private val ownedItemIds = mutableSetOf() - @Before - fun setUp() { + val robot = PlayerTvRobot(composeRule) { + composeRule.activityRule.scenario.onActivity { activity -> + activity.onBackPressedDispatcher.onBackPressed() + } + } + + fun start() { LoopbackNetworkJournal(context).clear() RecordingAppLauncher.reset() scenarioToken = UUID.randomUUID().toString() @@ -105,8 +563,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { server.start() } - @After - fun tearDown() { + fun close() { var teardownFailure: Throwable? = null runCatching { if (composeRule.activityRule.scenario.state != Lifecycle.State.DESTROYED) { @@ -147,355 +604,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { teardownFailure?.let { throw it } } - @Test - fun movieScreen_realRemoteControlsPanelsAndRecreation_restoreFocusTracksAndMediaState() { - val itemId = 7901 - val media = MovieMediaRoots(itemId) - server.reset(movieRoutes(itemId, watchingTime = 0, media = media)) - launchPlayer( - itemId = itemId, - startMode = PlayerStartMode.StartFromBeginning, - ) - - assertFocusedPlayPause() - awaitPlayerReady() - awaitPlayerCondition("initial movie position advances") { - playerPosition() >= POSITION_FENCE_MS - } - - pressBack() - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("media key pauses playback") { - !playerIsPlaying() - } - assertFocusedPlayPause() - pressBack() - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("media key resumes playback") { - playerIsPlaying() - } - assertFocusedPlayPause() - pressBack() - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("second media key pauses playback") { - !playerIsPlaying() - } - assertFocusedPlayPause() - - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_UP) - assertFocusedSeekBar() - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) - assertFocusedPlayPause() - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_mark_watched)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) - - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - assertFocusedText(context.getString(R.string.player_sound_stereo)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(ENGLISH_AUDIO_LABEL) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) - assertFocusedText(SPANISH_AUDIO_LABEL) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerCondition("Spanish audio is selected in UI state and Media3") { - selectedAudioLanguage() == SPANISH_LANGUAGE && - preferredAudioLanguage() == SPANISH_LANGUAGE - } - - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(SUBTITLE_LANGUAGE) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerCondition("external subtitle is persisted and selected in Media3") { - preferredSubtitleLanguage() == SUBTITLE_LANGUAGE && - selectedTextTrack() && - preferredTextLanguages().contains(SUBTITLE_LANGUAGE) - } - pressBack() - assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) - assertFocusedText(context.getString(R.string.player_button_mark_watched)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) - assertFocusedPlayPause() - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerCondition("selected external subtitle loads during playback") { - playerIsPlaying() - } - awaitJournalPath("${media.high}/subtitle.vtt") - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerCondition("playback pauses after external subtitle request") { - !playerIsPlaying() - } - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_mark_watched)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_video)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - assertFocusedText(context.getString(R.string.player_aspect_auto)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) - assertFocusedText(HIGH_QUALITY_LABEL) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) - assertFocusedText(LOW_QUALITY_LABEL) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerCondition("manual quality changes the production Media3 item") { - currentMediaPath() == "${media.low}/master.m3u8" - } - awaitJournalPath("${media.low}/master.m3u8") - - pressBack() - assertFocusedText(context.getString(R.string.player_button_video)) - pressBack() - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_DOWN) - assertFocusedPlayPause() - - val previousActivity = AtomicReference() - composeRule.activityRule.scenario.onActivity(previousActivity::set) - composeRule.activityRule.scenario.recreate() - setPlayerContent() - composeRule.activityRule.scenario.onActivity { recreatedActivity -> - assertTrue( - "ActivityScenario.recreate must replace the host activity", - recreatedActivity !== previousActivity.get(), - ) - } - assertFocusedPlayPause() - awaitPlayerReady() - awaitPlayerCondition("recreated UI state restores audio and subtitle choices") { - preferredAudioLanguage() == SPANISH_LANGUAGE && - preferredSubtitleLanguage() == SUBTITLE_LANGUAGE - } - awaitPlayerCondition("recreated Media3 restores audio and subtitle choices") { - selectedAudioLanguage() == SPANISH_LANGUAGE && - selectedTextTrack() && - preferredTextLanguages().contains(SUBTITLE_LANGUAGE) - } - - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_mark_watched)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - assertFocusedText(context.getString(R.string.player_button_video)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - assertFocusedText(context.getString(R.string.player_aspect_auto)) - pressBack() - assertFalse( - "Video-settings panel Back must not pop PlayerScreen after recreation", - isTextDisplayed(HOST_TEXT), - ) - assertFocusedText(context.getString(R.string.player_button_video)) - - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) - assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - assertFocusedText(context.getString(R.string.player_sound_stereo)) - assertEquals(SPANISH_LANGUAGE, preferredAudioLanguage()) - assertEquals(SUBTITLE_LANGUAGE, preferredSubtitleLanguage()) - pressBack() - assertFalse( - "Audio/subtitle panel Back must not pop PlayerScreen after recreation", - isTextDisplayed(HOST_TEXT), - ) - assertFocusedText(context.getString(R.string.player_button_audio_subtitles)) - - pressBack() - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("recreated playback starts or replays before seek checks") { - playerIsPlaying() && playerPosition() >= POSITION_FENCE_MS - } - assertFocusedPlayPause() - pressBack() - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("recreated playback pauses from the player surface") { - !playerIsPlaying() && playerPosition() >= POSITION_FENCE_MS - } - assertFocusedPlayPause() - pressBack() - assertFocusedPlayerSurface() - val beforeBackwardSeek = playerPosition() - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_LEFT) - awaitPlayerCondition("D-pad left seeks backward") { - playerPosition() < beforeBackwardSeek - } - awaitText(context.getString(R.string.player_seek_backward, SEEK_STEP_SECONDS)) - assertFocusedPlayerSurface() - val beforeForwardSeek = playerPosition() - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_RIGHT) - awaitPlayerCondition("D-pad right seeks forward") { - playerPosition() > beforeForwardSeek - } - awaitText(context.getString(R.string.player_seek_forward, SEEK_STEP_SECONDS)) - assertFocusedPlayerSurface() - assertEquals(0, server.requestJournal.unknownRequests.size) - - pressBack() - awaitPlayerCondition("recreated PlayerScreen exits on the unchanged second Back") { - isTextDisplayed(HOST_TEXT) - } - } - - @Test - fun movieScreen_continueCrossesSavedFence_andSeparatesPauseBackgroundAndExitSaves() { - val itemId = 7902 - val media = MovieMediaRoots(itemId) - server.reset(movieRoutes(itemId, watchingTime = SAVED_POSITION_SECONDS, media = media)) - launchPlayer(itemId) - - assertFocusedText(context.getString(R.string.player_resume_continue)) - assertTrue(playerPosition() < SAVED_POSITION_FENCE_MS) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerCondition("Continue crosses the saved-position fence") { - playerPosition() >= SAVED_POSITION_FENCE_MS - } - assertFocusedPlayerSurface() - - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("pause is observable before its save") { - !playerIsPlaying() - } - assertFocusedPlayPause() - val pauseSave = awaitProgressRequest("pause progress save", itemId, video = 1, season = null) - assertProgressTimeAtLeast(pauseSave, MIN_SAVED_TIME_SECONDS) - - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerCondition("play resumes before background") { - playerIsPlaying() - } - composeRule.activityRule.scenario.moveToState(Lifecycle.State.CREATED) - val backgroundSave = awaitProgressRequest( - "background progress save", - itemId, - video = 1, - season = null, - ) - assertProgressTimeAtLeast(backgroundSave, MIN_SAVED_TIME_SECONDS) - - composeRule.activityRule.scenario.moveToState(Lifecycle.State.RESUMED) - setPlayerContentIfMissing() - awaitPlayerCondition("background keeps the player paused") { - !playerIsPlaying() - } - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("play resumes before exit") { - playerIsPlaying() - } - assertFocusedPlayPause() - - pressBack() - assertFocusedPlayerSurface() - pressBack() - val exitSave = awaitProgressRequest("exit progress save", itemId, video = 1, season = null) - assertProgressTimeAtLeast(exitSave, MIN_SAVED_TIME_SECONDS) - awaitPlayerCondition("Back exits only after the final progress write drains") { - isTextDisplayed(HOST_TEXT) - } - - assertTrue(pauseSave !== backgroundSave) - assertTrue(backgroundSave !== exitSave) - } - - @Test - fun movieScreen_failedMedia_focusesRetry_recoversAndBackDrainsProgressBeforeExit() { - val itemId = 7903 - val media = MovieMediaRoots(itemId) - server.reset(retryMovieRoutes(itemId, media)) - launchPlayer( - itemId = itemId, - startMode = PlayerStartMode.StartFromBeginning, - ) - - assertFocusedPlayPause() - assertFocusedTextEventually(context.getString(R.string.player_error_retry)) - assertEquals(RETRY_FAILURE_REQUESTS, routeRequestCount(media.high, "master")) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - awaitPlayerReady() - awaitPlayerCondition("Retry reaches real playback") { - playerIsPlaying() && currentMediaPath() == "${media.high}/master.m3u8" - } - assertTrue(routeRequestCount(media.high, "master") > RETRY_FAILURE_REQUESTS) - - assertFocusedPlayPause() - pressBack() - assertFocusedPlayerSurface() - pressBack() - awaitProgressRequest("Retry journey exit save", itemId, video = 1, season = null) - awaitPlayerCondition("Back exits recovered playback") { - isTextDisplayed(HOST_TEXT) - } - } - - @Test - fun seriesScreen_nextEpisodeDpadJourney_usesDistinctRoutesAndEpisodeProgressIdentity() { - val itemId = 7904 - val media = SeriesMediaRoots(itemId) - server.reset(seriesRoutes(itemId, media)) - launchPlayer( - itemId = itemId, - seasonNumber = 1, - episodeNumber = 1, - startMode = PlayerStartMode.StartFromBeginning, - ) - - assertFocusedPlayPause() - awaitPlayerReady() - awaitJournalPath("${media.episodeOne}/master.m3u8") - assertFocusedTextEventually( - text = context.getString(R.string.player_next_episode_countdown, 15) - .substringBefore("15"), - substring = true, - ) - sendPlayerKey(AndroidKeyEvent.KEYCODE_DPAD_CENTER) - - val firstEpisodeSave = awaitProgressRequest( - "first episode transition save", - itemId, - video = 1, - season = 1, - ) - assertNull(firstEpisodeSave.url.queryParameter("episode")) - awaitJournalPath("${media.episodeTwo}/master.m3u8") - awaitPlayerCondition("second episode owns the active production player") { - currentMediaPath() == "${media.episodeTwo}/master.m3u8" - } - awaitText(context.getString(R.string.player_season_episode_title, 1, 2, "Second episode")) - awaitPlayerReady() - - if (isTextDisplayed(context.getString(R.string.player_button_audio_subtitles))) { - pressBack() - } - assertFocusedPlayerSurface() - sendPlayerKey(AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) - awaitPlayerCondition("second episode pause is observable") { - !playerIsPlaying() - } - val secondEpisodeSave = awaitProgressRequest( - "second episode pause save", - itemId, - video = 2, - season = 1, - ) - assertNull(secondEpisodeSave.url.queryParameter("episode")) - - assertTrue( - "Expected distinct episode media routes: ${server.requestJournal.entries}", - server.requestJournal.entries.any { it.path == "${media.episodeOne}/master.m3u8" } && - server.requestJournal.entries.any { it.path == "${media.episodeTwo}/master.m3u8" }, - ) - assertEquals("1", firstEpisodeSave.url.queryParameter("video")) - assertEquals("2", secondEpisodeSave.url.queryParameter("video")) - assertEquals(0, server.requestJournal.unknownRequests.size) - } - - private fun launchPlayer( + fun launchPlayer( itemId: Int, seasonNumber: Int? = null, episodeNumber: Int? = null, @@ -521,7 +630,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { } } - private fun setPlayerContent() { + fun setPlayerContent() { composeRule.activityRule.scenario.onActivity { activity -> activity.setContent { PuberTheme { @@ -550,7 +659,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { } } - private fun setPlayerContentIfMissing() { + fun setPlayerContentIfMissing() { if (runCatching { uiPlayerRead { playbackState } }.getOrNull() == null) { setPlayerContent() } @@ -567,20 +676,20 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { return "currentScreen$flowScopeName$screenKey:$screenKey" } - private fun preferredAudioLanguage(): String? = + fun preferredAudioLanguage(): String? = PlayerPreferencesRepository(context).getPreferredAudioLang(currentItemId) - private fun preferredSubtitleLanguage(): String? = + fun preferredSubtitleLanguage(): String? = PlayerPreferencesRepository(context).getPreferredSubtitleLang(currentItemId) - private fun playerPosition(): Long = uiPlayerRead { currentPosition } ?: 0L + fun playerPosition(): Long = uiPlayerRead { currentPosition } ?: 0L - private fun playerIsPlaying(): Boolean = uiPlayerRead { isPlaying } == true + fun playerIsPlaying(): Boolean = uiPlayerRead { isPlaying } == true - private fun currentMediaPath(): String? = + fun currentMediaPath(): String? = uiPlayerRead { currentMediaItem?.localConfiguration?.uri?.encodedPath } - private fun selectedAudioLanguage(): String? = uiPlayerRead { + fun selectedAudioLanguage(): String? = uiPlayerRead { currentTracks .groups .filter { it.type == C.TRACK_TYPE_AUDIO } @@ -589,23 +698,23 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { ?.language } - private fun selectedTextTrack(): Boolean = uiPlayerRead { + fun selectedTextTrack(): Boolean = uiPlayerRead { currentTracks .groups .filter { it.type == C.TRACK_TYPE_TEXT } .any { it.isSelected } } == true - private fun preferredTextLanguages(): List = + fun preferredTextLanguages(): List = uiPlayerRead { trackSelectionParameters.preferredTextLanguages.toList() }.orEmpty() - private fun awaitPlayerReady() { + fun awaitPlayerReady() { awaitPlayerCondition("Media3 READY without PlayerScreen error") { uiPlayerRead { playbackState } == Player.STATE_READY } } - private fun awaitPlayerCondition( + fun awaitPlayerCondition( label: String, condition: () -> Boolean, ) { @@ -645,8 +754,8 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { return requireNotNull(result.get()).getOrThrow() } - private fun assertFocusedPlayPause() { - onPlayerScreen(composeRule) { + fun assertFocusedPlayPause() { + ComposeScreen.onComposeScreen(composeRule) { playPauseButton.assertIsDisplayed() playPauseButton.assertIsFocused() } @@ -656,8 +765,8 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { ) } - private fun assertFocusedSeekBar() { - onPlayerScreen(composeRule) { + fun assertFocusedSeekBar() { + ComposeScreen.onComposeScreen(composeRule) { seekBar.assertIsDisplayed() seekBar.assertIsFocused() } @@ -678,9 +787,9 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { ) } - private fun assertFocusedPlayerSurface() { - awaitAbsent(context.getString(R.string.player_button_audio_subtitles)) - onPlayerScreen(composeRule) { + fun assertFocusedPlayerSurface() { + awaitAbsentTag(PlayerScreenTestTags.AudioSubtitles) + ComposeScreen.onComposeScreen(composeRule) { playerSurface.assertIsDisplayed() playerSurface.assertIsFocused() } @@ -713,28 +822,27 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { } } - private fun assertFocusedText( - text: String, - substring: Boolean = false, - ) { - onPlayerScreen(composeRule) { - focusedText(text, substring).assertIsDisplayed() - focusedText(text, substring).assertIsFocused() + fun assertFocusedTag(tag: String, description: String) { + assertSingleFocusedNode(focusedTagMatcher(tag), description) + ComposeScreen.onComposeScreen(composeRule) { + focusedTag(tag).assertIsDisplayed() + focusedTag(tag).assertIsFocused() } - assertSingleFocusedNode(focusedTextMatcher(text, substring), "control '$text'") } - private fun assertFocusedTextEventually( - text: String, - substring: Boolean = false, - ) { - val matcher = focusedTextMatcher(text, substring) + fun assertFocusedPanelItem(group: String, index: Int) { + val tag = PlayerScreenTestTags.panelItem(group, index) + assertFocusedTag(tag, "$group panel item $index") + } + + fun assertFocusedTagEventually(tag: String, description: String) { + val matcher = focusedTagMatcher(tag) composeRule.waitUntil(PLAYER_TIMEOUT_MS) { composeRule.onAllNodes(matcher, useUnmergedTree = true) .fetchSemanticsNodes() .size == 1 } - assertSingleFocusedNode(matcher, "control '$text'") + assertSingleFocusedNode(matcher, description) } private fun assertSingleFocusedNode( @@ -775,9 +883,12 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { interaction.assertIsDisplayed().assertIsFocused() } - private fun focusedTextMatcher(text: String, substring: Boolean): SemanticsMatcher { - val textMatcher = hasText(text, substring = substring) - return isFocused() and (textMatcher or hasAnyDescendant(textMatcher)) + private fun focusedTagMatcher(tag: String): SemanticsMatcher { + val tagMatcher = hasTestTag(tag) + return isFocused() and ( + tagMatcher or + hasAnyDescendant(tagMatcher) + ) } private fun focusedSummary(nodes: List): String = @@ -790,19 +901,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { composeRule.onAllNodes(isFocused(), useUnmergedTree = true) .fetchSemanticsNodes() - private fun sendPlayerKey(keyCode: Int) { - instrumentation.sendKeyDownUpSync(keyCode) - composeRule.waitForIdle() - } - - private fun pressBack() { - composeRule.activityRule.scenario.onActivity { activity -> - activity.onBackPressedDispatcher.onBackPressed() - } - composeRule.waitForIdle() - } - - private fun awaitText(text: String) { + fun awaitText(text: String) { composeRule.waitUntil(PLAYER_TIMEOUT_MS) { composeRule.onAllNodesWithText(text, substring = true) .fetchSemanticsNodes() @@ -811,20 +910,25 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { composeRule.onNodeWithText(text, substring = true).assertIsDisplayed() } - private fun awaitAbsent(text: String) { + private fun awaitAbsentTag(tag: String) { composeRule.waitUntil(FOCUS_TIMEOUT_MS) { - composeRule.onAllNodesWithText(text, useUnmergedTree = true) + composeRule.onAllNodes(hasTestTag(tag), useUnmergedTree = true) .fetchSemanticsNodes() .isEmpty() } } - private fun isTextDisplayed(text: String): Boolean = + fun isTagDisplayed(tag: String): Boolean = + composeRule.onAllNodes(hasTestTag(tag), useUnmergedTree = true) + .fetchSemanticsNodes() + .isNotEmpty() + + fun isTextDisplayed(text: String): Boolean = composeRule.onAllNodesWithText(text, useUnmergedTree = true) .fetchSemanticsNodes() .isNotEmpty() - private fun awaitJournalPath(path: String) { + fun awaitJournalPath(path: String) { try { composeRule.waitUntil(PLAYER_TIMEOUT_MS) { server.requestJournal.entries.any { it.path == path } @@ -837,7 +941,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { } } - private fun awaitProgressRequest( + fun awaitProgressRequest( description: String, itemId: Int, video: Int, @@ -850,7 +954,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { request.url.queryParameter("time")?.toIntOrNull() != null } - private fun assertProgressTimeAtLeast(request: RecordedRequest, expectedSeconds: Int) { + fun assertProgressTimeAtLeast(request: RecordedRequest, expectedSeconds: Int) { val savedTime = request.url.queryParameter("time")?.toIntOrNull() assertNotNull("Missing typed progress time in ${request.url}", savedTime) assertTrue( @@ -872,10 +976,10 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { error("unreachable") } - private fun routeRequestCount(root: String, leaf: String): Int = + fun routeRequestCount(root: String, leaf: String): Int = server.requestJournal.matchedRoutes[mediaRouteId(root, leaf)] ?: 0 - private fun movieRoutes( + fun movieRoutes( itemId: Int, watchingTime: Int, media: MovieMediaRoots, @@ -885,7 +989,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { details = movieDetails(itemId, watchingTime, media), ) + mediaRoutes(media.high) + mediaRoutes(media.low) - private fun retryMovieRoutes( + fun retryMovieRoutes( itemId: Int, media: MovieMediaRoots, ): List { @@ -907,7 +1011,7 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { ) + mediaRoutes(media.high, masterResponse = retrySequence) + mediaRoutes(media.low) } - private fun seriesRoutes( + fun seriesRoutes( itemId: Int, media: SeriesMediaRoots, ): List = @@ -1135,39 +1239,36 @@ internal class PlayerScreenE2ETest : PlayerInstrumentationTestCase() { return requireNotNull(result.get()).getOrThrow() } - private data class MovieMediaRoots(val itemId: Int) { - val high = "/media/movie-$itemId/high" - val low = "/media/movie-$itemId/low" - } - - private data class SeriesMediaRoots(val itemId: Int) { - val episodeOne = "/media/series-$itemId/episode-1" - val episodeTwo = "/media/series-$itemId/episode-2" - } +} - private companion object { - const val HLS_CONTENT_TYPE = "application/vnd.apple.mpegurl" - const val PLAYER_TIMEOUT_MS = 30_000L - const val FOCUS_TIMEOUT_MS = 5_000L - const val POSITION_FENCE_MS = 500L - const val SAVED_POSITION_SECONDS = 2 - const val SAVED_POSITION_FENCE_MS = 1_750L - const val MIN_SAVED_TIME_SECONDS = 1 - const val SEEK_STEP_SECONDS = 10 - const val RETRY_FAILURE_REQUESTS = 6 - const val FULLSCREEN_FOCUS_FRACTION = 0.8f - const val ENGLISH_AUDIO_LABEL = "English" - const val SPANISH_AUDIO_LABEL = "EspaƱol" - const val SPANISH_LANGUAGE = "es" - const val SUBTITLE_LANGUAGE = "en" - const val HIGH_QUALITY_LABEL = "720p" - const val LOW_QUALITY_LABEL = "360p" - const val EPISODE_ONE_ID_OFFSET = 11 - const val EPISODE_TWO_ID_OFFSET = 12 +private data class MovieMediaRoots(val itemId: Int) { + val high = "/media/movie-$itemId/high" + val low = "/media/movie-$itemId/low" +} - } +private data class SeriesMediaRoots(val itemId: Int) { + val episodeOne = "/media/series-$itemId/episode-1" + val episodeTwo = "/media/series-$itemId/episode-2" } +private const val HLS_CONTENT_TYPE = "application/vnd.apple.mpegurl" +private const val PLAYER_TIMEOUT_MS = 30_000L +private const val FOCUS_TIMEOUT_MS = 5_000L +private const val POSITION_FENCE_MS = 500L +private const val SAVED_POSITION_SECONDS = 2 +private const val SAVED_POSITION_FENCE_MS = 1_750L +private const val MIN_SAVED_TIME_SECONDS = 1 +private const val SEEK_STEP_SECONDS = 10 +private const val RETRY_FAILURE_REQUESTS = 6 +private const val FULLSCREEN_FOCUS_FRACTION = 0.8f +private const val ENGLISH_AUDIO_LABEL = "English" +private const val SPANISH_AUDIO_LABEL = "EspaƱol" +private const val SPANISH_LANGUAGE = "es" +private const val SUBTITLE_LANGUAGE = "en" +private const val HIGH_QUALITY_LABEL = "720p" +private const val LOW_QUALITY_LABEL = "360p" +private const val EPISODE_ONE_ID_OFFSET = 11 +private const val EPISODE_TWO_ID_OFFSET = 12 private const val HOST_TEXT = "Player E2E host" @Parcelize diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerTvRobot.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerTvRobot.kt new file mode 100644 index 00000000..02012af1 --- /dev/null +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerTvRobot.kt @@ -0,0 +1,223 @@ +package com.kino.puber.ui.feature.player.component + +import android.view.KeyEvent +import androidx.compose.ui.semantics.SemanticsNode +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.assertIsFocused +import androidx.compose.ui.test.hasTestTag +import androidx.compose.ui.test.isFocusable +import androidx.compose.ui.test.isFocused +import androidx.compose.ui.test.junit4.ComposeContentTestRule +import androidx.compose.ui.test.onRoot +import androidx.test.platform.app.InstrumentationRegistry +import io.github.kakaocup.compose.node.element.KNode +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue + +internal class PlayerTvRobot( + private val rule: ComposeContentTestRule, + private val canonicalBack: (() -> Unit)? = null, +) { + private val screen = PlayerComposeScreen(rule) + + val focus = PlayerFocusContract(rule, screen) + + fun press(key: PlayerRemoteKey) { + pressWithoutSettling(key) + rule.waitForIdle() + } + + fun pressBack() { + canonicalBack?.invoke() ?: press(PlayerRemoteKey.Back) + rule.waitForIdle() + } + + fun pressWithoutSettling(key: PlayerRemoteKey) { + val instrumentation = InstrumentationRegistry.getInstrumentation() + instrumentation.sendKeySync(KeyEvent(KeyEvent.ACTION_DOWN, key.keyCode)) + instrumentation.sendKeySync(KeyEvent(KeyEvent.ACTION_UP, key.keyCode)) + } + + fun advanceOneFrame() { + rule.mainClock.advanceTimeByFrame() + rule.waitForIdle() + } + + fun advanceClockBy(milliseconds: Long) { + rule.mainClock.advanceTimeBy(milliseconds) + rule.waitForIdle() + } + + fun focusButton(button: KNode, dpadRightSteps: Int) { + repeat(dpadRightSteps) { + press(PlayerRemoteKey.Right) + } + button.assertIsFocused() + } + + fun waitForControlsToBeDisposed() { + rule.waitUntil(timeoutMillis = FOCUS_TIMEOUT_MS) { + rule.onAllNodes( + hasTestTag(PlayerScreenTestTags.AudioSubtitles), + useUnmergedTree = true, + ).fetchSemanticsNodes().isEmpty() + } + } + + fun waitUntilFocused(button: KNode) { + rule.waitUntil(timeoutMillis = FOCUS_TIMEOUT_MS) { + runCatching { + button.assertIsFocused() + true + }.getOrDefault(false) + } + button.assertIsFocused() + } + + fun assertControlsVisible(controlsVisible: Boolean) { + assertTrue(controlsVisible) + screen.audioSubtitlesButton.assertIsDisplayed() + } + + fun screen(actions: PlayerComposeScreen.() -> Unit) { + screen.actions() + } + + private companion object { + const val FOCUS_TIMEOUT_MS = 5_000L + } +} + +internal enum class PlayerRemoteKey(internal val keyCode: Int) { + Up(KeyEvent.KEYCODE_DPAD_UP), + Down(KeyEvent.KEYCODE_DPAD_DOWN), + Left(KeyEvent.KEYCODE_DPAD_LEFT), + Right(KeyEvent.KEYCODE_DPAD_RIGHT), + Select(KeyEvent.KEYCODE_DPAD_CENTER), + Enter(KeyEvent.KEYCODE_ENTER), + Back(KeyEvent.KEYCODE_BACK), + PlayPause(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE), + Play(KeyEvent.KEYCODE_MEDIA_PLAY), + Pause(KeyEvent.KEYCODE_MEDIA_PAUSE), + Rewind(KeyEvent.KEYCODE_MEDIA_REWIND), + FastForward(KeyEvent.KEYCODE_MEDIA_FAST_FORWARD), + SkipBackward(KeyEvent.KEYCODE_MEDIA_SKIP_BACKWARD), + SkipForward(KeyEvent.KEYCODE_MEDIA_SKIP_FORWARD), +} + +internal class PlayerFocusContract( + private val rule: ComposeContentTestRule, + private val screen: PlayerComposeScreen, +) { + fun assertExactlyOneFocusedNode() { + val focusedNodes = focusedNodes() + assertEquals( + "PlayerScreen must have exactly one focused semantics node; " + + "focusedBounds=${focusedNodes.map(SemanticsNode::boundsInRoot)}", + 1, + focusedNodes.size, + ) + } + + fun assertFocusedPlayerSurface() { + screen.playerSurface.assertIsDisplayed() + screen.playerSurface.assertIsFocused() + val focusedNode = focusedNode() + val rootBounds = rootBounds() + assertTrue( + "Focused player anchor must cover the root width: " + + "focused=${focusedNode.boundsInRoot}, root=$rootBounds", + focusedNode.boundsInRoot.width >= rootBounds.width * 0.9f, + ) + assertTrue( + "Focused player anchor must cover the root height: " + + "focused=${focusedNode.boundsInRoot}, root=$rootBounds", + focusedNode.boundsInRoot.height >= rootBounds.height * 0.9f, + ) + } + + fun assertFocusedSeekBar() { + screen.seekBar.assertIsDisplayed() + screen.seekBar.assertIsFocused() + val focusedNode = focusedNode() + val rootWidth = rootBounds().width + assertTrue( + "Seek bar must be the focused wide control: " + + "focused=${focusedNode.boundsInRoot}, rootWidth=$rootWidth", + focusedNode.boundsInRoot.width >= rootWidth * 0.5f, + ) + assertTrue( + "Seek bar must not be the full-screen player anchor: " + + "focused=${focusedNode.boundsInRoot}, rootWidth=$rootWidth", + focusedNode.boundsInRoot.width < rootWidth * 0.9f, + ) + } + + fun assertFocusedControl() { + screen.playPauseButton.assertIsDisplayed() + screen.playPauseButton.assertIsFocused() + waitUntilFocusedTarget { node -> + val rootBounds = rootBounds() + node.boundsInRoot.width < rootBounds.width * 0.5f && + node.boundsInRoot.height < rootBounds.height * 0.9f + } + val focusedNode = focusedNode() + val rootBounds = rootBounds() + assertTrue( + "Control focus must not remain on the full-screen player anchor: " + + "focused=${focusedNode.boundsInRoot}, root=$rootBounds", + focusedNode.boundsInRoot.width < rootBounds.width * 0.5f && + focusedNode.boundsInRoot.height < rootBounds.height * 0.9f, + ) + } + + fun assertPlayerAnchorFocusable(expected: Boolean) { + val rootBounds = rootBounds() + val fullScreenFocusableCount = rule + .onAllNodes(isFocusable(), useUnmergedTree = true) + .fetchSemanticsNodes() + .count { node -> + node.boundsInRoot.width >= rootBounds.width * 0.9f && + node.boundsInRoot.height >= rootBounds.height * 0.9f + } + assertEquals( + "Only the typed Player owner may expose the full-screen focus anchor; root=$rootBounds", + if (expected) 1 else 0, + fullScreenFocusableCount, + ) + } + + fun assertHiddenControlsAreNotFocused() { + screen.audioSubtitlesButton.assertDoesNotExist() + screen.videoSettingsButton.assertDoesNotExist() + } + + fun assertHiddenPlayerIsNotFocused() { + val focusedNode = focusedNode() + val rootBounds = rootBounds() + assertFalse( + "Player anchor must lose focus after controls reopen: " + + "focused=${focusedNode.boundsInRoot}, root=$rootBounds", + focusedNode.boundsInRoot.width >= rootBounds.width * 0.9f, + ) + } + + private fun focusedNode(): SemanticsNode = focusedNodes().single() + + private fun focusedNodes(): List = rule + .onAllNodes(isFocused(), useUnmergedTree = true) + .fetchSemanticsNodes() + + private fun rootBounds() = rule.onRoot().fetchSemanticsNode().boundsInRoot + + private fun waitUntilFocusedTarget(predicate: (SemanticsNode) -> Boolean) { + rule.waitUntil(timeoutMillis = FOCUS_TIMEOUT_MS) { + focusedNodes().singleOrNull()?.let(predicate) == true + } + } + + private companion object { + const val FOCUS_TIMEOUT_MS = 5_000L + } +} diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt index 7f156750..c573aaec 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerVideoSurfaceTest.kt @@ -29,71 +29,83 @@ internal class PlayerVideoSurfaceTest : PlayerInstrumentationTestCase() { val composeRule = createAndroidComposeRule() @Test - fun playbackSnapshots_reachAttachedWindow_andClearWithPlayerOnRelease() { + fun playbackSnapshots_reachAttachedWindow_andClearWithPlayerOnRelease() = run { val contentState = mutableStateOf(content()) val surfaceVisible = mutableStateOf(true) val playerViewReference = AtomicReference() var player: ExoPlayer? = null - composeRule.setContent { - if (surfaceVisible.value) { - MaterialTheme { - PlayerVideoSurface( - content = contentState.value, - exoPlayer = { player }, - playerViewFactory = { context -> - player = player ?: ExoPlayer.Builder(context).build() - PlayerView(context).also(playerViewReference::set) - }, - ) + step("Attach the production video surface to an idle player") { + composeRule.setContent { + if (surfaceVisible.value) { + MaterialTheme { + PlayerVideoSurface( + content = contentState.value, + exoPlayer = { player }, + playerViewFactory = { context -> + player = player ?: ExoPlayer.Builder(context).build() + PlayerView(context).also(playerViewReference::set) + }, + ) + } } } - } - composeRule.waitUntil { playerViewReference.get()?.isAttachedToWindow == true } - composeRule.runOnIdle { - val playerView = playerViewReference.get() - assertFalse(playerView.keepScreenOn) - assertSame(player, playerView.player) - assertWindowKeepScreenOn(expected = false) + composeRule.waitUntil { playerViewReference.get()?.isAttachedToWindow == true } + composeRule.runOnIdle { + val playerView = playerViewReference.get() + assertFalse(playerView.keepScreenOn) + assertSame(player, playerView.player) + assertWindowKeepScreenOn(expected = false) + } } - publish(contentState, playbackState = Player.STATE_READY, playWhenReady = true) - assertAttachedKeepScreenOn(playerViewReference, expected = true) - - publish(contentState, playbackState = Player.STATE_BUFFERING, playWhenReady = true) - assertAttachedKeepScreenOn(playerViewReference, expected = true) - - publish(contentState, playbackState = Player.STATE_READY, playWhenReady = false) - assertAttachedKeepScreenOn(playerViewReference, expected = false) + step("Acquire keep-screen-on ownership while READY and playing") { + publish(contentState, playbackState = Player.STATE_READY, playWhenReady = true) + assertAttachedKeepScreenOn(playerViewReference, expected = true) + } - publish( - contentState = contentState, - playbackState = Player.STATE_READY, - playWhenReady = true, - suppressionReason = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS, - ) - assertAttachedKeepScreenOn(playerViewReference, expected = false) + step("Retain keep-screen-on ownership while actively buffering") { + publish(contentState, playbackState = Player.STATE_BUFFERING, playWhenReady = true) + assertAttachedKeepScreenOn(playerViewReference, expected = true) + } - composeRule.runOnIdle { - surfaceVisible.value = false + step("Release keep-screen-on ownership when playback pauses") { + publish(contentState, playbackState = Player.STATE_READY, playWhenReady = false) + assertAttachedKeepScreenOn(playerViewReference, expected = false) } - composeRule.waitUntil { - playerViewReference.get().player == null && - !playerViewReference.get().keepScreenOn + + step("Keep ownership released while playback is suppressed") { + publish( + contentState = contentState, + playbackState = Player.STATE_READY, + playWhenReady = true, + suppressionReason = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS, + ) + assertAttachedKeepScreenOn(playerViewReference, expected = false) } - composeRule.runOnIdle { - val playerView = playerViewReference.get() - assertFalse(playerView.keepScreenOn) - assertNull(playerView.player) - assertWindowKeepScreenOn(expected = false) - player?.release() - player = null + + step("Detach the released surface and clear player and window ownership") { + composeRule.runOnIdle { + surfaceVisible.value = false + } + composeRule.waitUntil { + playerViewReference.get().player == null && + !playerViewReference.get().keepScreenOn + } + composeRule.runOnIdle { + val playerView = playerViewReference.get() + assertFalse(playerView.keepScreenOn) + assertNull(playerView.player) + assertWindowKeepScreenOn(expected = false) + player?.release() + player = null + } } } @Test - fun activeBuffering_reacquiresWindowOwnershipAtPlayerViewAttachBoundary() { + fun activeBuffering_reacquiresWindowOwnershipAtPlayerViewAttachBoundary() = run { val contentState = mutableStateOf( content().withPlaybackSnapshot( PlaybackStatePolicy.derive( @@ -107,102 +119,120 @@ internal class PlayerVideoSurfaceTest : PlayerInstrumentationTestCase() { val playerViewReference = AtomicReference() var player: ExoPlayer? = null - composeRule.setContent { - MaterialTheme { - PlayerVideoSurface( - content = contentState.value, - exoPlayer = { player }, - playerViewFactory = { context -> - player = ExoPlayer.Builder(context).build() - object : PlayerView(context) { - override fun onAttachedToWindow() { - super.onAttachedToWindow() - composeRule.activity.window.clearFlags( - WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, - ) - } - }.also(playerViewReference::set) - }, - ) + step("Attach an actively buffering surface after the view clears the window flag") { + composeRule.setContent { + MaterialTheme { + PlayerVideoSurface( + content = contentState.value, + exoPlayer = { player }, + playerViewFactory = { context -> + player = ExoPlayer.Builder(context).build() + object : PlayerView(context) { + override fun onAttachedToWindow() { + super.onAttachedToWindow() + composeRule.activity.window.clearFlags( + WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, + ) + } + }.also(playerViewReference::set) + }, + ) + } } } - composeRule.waitUntil { playerViewReference.get()?.isAttachedToWindow == true } - composeRule.waitUntil { - composeRule.activity.window.attributes.flags and - WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON != 0 + step("Reacquire view and window ownership at the attach boundary") { + composeRule.waitUntil { playerViewReference.get()?.isAttachedToWindow == true } + composeRule.waitUntil { + composeRule.activity.window.attributes.flags and + WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON != 0 + } + composeRule.runOnIdle { + assertTrue(playerViewReference.get().keepScreenOn) + assertWindowKeepScreenOn(expected = true) + } } - composeRule.runOnIdle { - assertTrue(playerViewReference.get().keepScreenOn) - assertWindowKeepScreenOn(expected = true) - playerViewReference.get().player = null - player?.release() - player = null + + step("Detach the player before releasing the real ExoPlayer") { + composeRule.runOnIdle { + playerViewReference.get().player = null + player?.release() + player = null + } } } @Test - fun preExistingWindowKeepScreenOn_survivesPlaybackTransitionsAndRelease() { + fun preExistingWindowKeepScreenOn_survivesPlaybackTransitionsAndRelease() = run { val contentState = mutableStateOf(content()) val surfaceVisible = mutableStateOf(true) val playerViewReference = AtomicReference() var player: ExoPlayer? = null - composeRule.runOnIdle { - composeRule.activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) - assertWindowKeepScreenOn(expected = true) + step("Establish pre-existing window keep-screen-on ownership") { + composeRule.runOnIdle { + composeRule.activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + assertWindowKeepScreenOn(expected = true) + } } try { - composeRule.setContent { - if (surfaceVisible.value) { - MaterialTheme { - PlayerVideoSurface( - content = contentState.value, - exoPlayer = { player }, - playerViewFactory = { context -> - player = player ?: ExoPlayer.Builder(context).build() - PlayerView(context).also(playerViewReference::set) - }, - ) + step("Attach the surface without claiming the pre-existing window flag") { + composeRule.setContent { + if (surfaceVisible.value) { + MaterialTheme { + PlayerVideoSurface( + content = contentState.value, + exoPlayer = { player }, + playerViewFactory = { context -> + player = player ?: ExoPlayer.Builder(context).build() + PlayerView(context).also(playerViewReference::set) + }, + ) + } } } + composeRule.waitUntil { playerViewReference.get()?.isAttachedToWindow == true } + assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) } - composeRule.waitUntil { playerViewReference.get()?.isAttachedToWindow == true } - assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) + step("Toggle view ownership through READY and BUFFERING") { + publish(contentState, playbackState = Player.STATE_READY, playWhenReady = true) + assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = true) - publish(contentState, playbackState = Player.STATE_READY, playWhenReady = true) - assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = true) - - publish(contentState, playbackState = Player.STATE_BUFFERING, playWhenReady = true) - assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = true) + publish(contentState, playbackState = Player.STATE_BUFFERING, playWhenReady = true) + assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = true) + } - publish(contentState, playbackState = Player.STATE_READY, playWhenReady = false) - assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) + step("Release only view ownership for pause, suppression, and ENDED") { + publish(contentState, playbackState = Player.STATE_READY, playWhenReady = false) + assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) - publish( - contentState = contentState, - playbackState = Player.STATE_READY, - playWhenReady = true, - suppressionReason = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS, - ) - assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) - - publish(contentState, playbackState = Player.STATE_ENDED, playWhenReady = true) - assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) + publish( + contentState = contentState, + playbackState = Player.STATE_READY, + playWhenReady = true, + suppressionReason = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS, + ) + assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) - composeRule.runOnIdle { - surfaceVisible.value = false - } - composeRule.waitUntil { - playerViewReference.get().player == null && - !playerViewReference.get().keepScreenOn + publish(contentState, playbackState = Player.STATE_ENDED, playWhenReady = true) + assertPreExistingWindowFlagPreserved(playerViewReference, viewExpected = false) } - composeRule.runOnIdle { - assertFalse(playerViewReference.get().keepScreenOn) - assertNull(playerViewReference.get().player) - assertWindowKeepScreenOn(expected = true) + + step("Detach the surface while preserving external window ownership") { + composeRule.runOnIdle { + surfaceVisible.value = false + } + composeRule.waitUntil { + playerViewReference.get().player == null && + !playerViewReference.get().keepScreenOn + } + composeRule.runOnIdle { + assertFalse(playerViewReference.get().keepScreenOn) + assertNull(playerViewReference.get().player) + assertWindowKeepScreenOn(expected = true) + } } } finally { try { diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt index 5689f878..82165c94 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt @@ -132,122 +132,173 @@ internal class PlaybackControllerDeviceTest : PlayerInstrumentationTestCase() { } @Test - fun progressiveMp4_reachesReadyRendersFrameAdvancesAndEnds() { - val probe = prepare(FixtureId.ProgressiveMp4, startPositionMs = 0L) + fun progressiveMp4_reachesReadyRendersFrameAdvancesAndEnds() = run { + lateinit var probe: PlayerProbe - await(probe.ready, "progressive READY") - await(probe.firstFrame, "progressive first rendered frame") - awaitCondition("progressive position advance") { - controller.currentPosition > 0L + step("Prepare the progressive fixture with the production player") { + probe = prepare(FixtureId.ProgressiveMp4, startPositionMs = 0L) } - await(probe.ended, "progressive ENDED") - assertNoPlaybackError(probe) - assertTrue( - "Expected a progressive MP4 request; journal=${server.requestJournal.entries}", - server.requestJournal.entries.any { - it.path == "/media/progressive.mp4" && - it.outcome is ResponseOutcome.Completed - }, - ) - assertEquals(0, server.requestJournal.unknownRequests.size) + step("Reach READY and render the first progressive frame") { + await(probe.ready, "progressive READY") + await(probe.firstFrame, "progressive first rendered frame") + } + + step("Advance progressive playback and reach ENDED") { + awaitCondition("progressive position advance") { + controller.currentPosition > 0L + } + await(probe.ended, "progressive ENDED") + } + + step("Verify progressive playback and its hermetic request journal") { + assertNoPlaybackError(probe) + assertTrue( + "Expected a progressive MP4 request; journal=${server.requestJournal.entries}", + server.requestJournal.entries.any { + it.path == "/media/progressive.mp4" && + it.outcome is ResponseOutcome.Completed + }, + ) + assertEquals(0, server.requestJournal.unknownRequests.size) + } } @Test - fun hlsVod_reachesReadyRendersFrameAdvancesAndEnds() { - val probe = prepare(FixtureId.HlsMaster, startPositionMs = 0L) + fun hlsVod_reachesReadyRendersFrameAdvancesAndEnds() = run { + lateinit var probe: PlayerProbe - await(probe.ready, "HLS READY") - await(probe.firstFrame, "HLS first rendered frame") - awaitCondition("HLS position advance") { - controller.currentPosition > 0L + step("Prepare the HLS fixture with the production player") { + probe = prepare(FixtureId.HlsMaster, startPositionMs = 0L) } - await(probe.ended, "HLS ENDED") - assertNoPlaybackError(probe) - val requests = server.requestJournal.entries - assertTrue( - "Expected HLS master and media playlist requests, journal=$requests", - requests.any { it.path == "/media/hls/master.m3u8" } && - requests.any { it.path == "/media/hls/video_360.m3u8" }, - ) - assertTrue( - "Expected HLS segment request, journal=$requests", - requests.any { it.path.startsWith("/media/hls/video_") && it.path.endsWith(".ts") }, - ) - assertEquals(0, server.requestJournal.unknownRequests.size) - } + step("Reach READY and render the first HLS frame") { + await(probe.ready, "HLS READY") + await(probe.firstFrame, "HLS first rendered frame") + } - @Test - fun progressivePlayback_controlsAndStartPositionUseRealPlayerEvents() { - val probe = prepare(FixtureId.ProgressiveMp4, startPositionMs = 1_000L) + step("Advance HLS playback and reach ENDED") { + awaitCondition("HLS position advance") { + controller.currentPosition > 0L + } + await(probe.ended, "HLS ENDED") + } - await(probe.ready, "progressive READY") - await(probe.firstFrame, "progressive first rendered frame") - awaitCondition("non-zero start position") { - controller.currentPosition >= 900L + step("Verify HLS playback and its manifest and segment requests") { + assertNoPlaybackError(probe) + val requests = server.requestJournal.entries + assertTrue( + "Expected HLS master and media playlist requests, journal=$requests", + requests.any { it.path == "/media/hls/master.m3u8" } && + requests.any { it.path == "/media/hls/video_360.m3u8" }, + ) + assertTrue( + "Expected HLS segment request, journal=$requests", + requests.any { it.path.startsWith("/media/hls/video_") && it.path.endsWith(".ts") }, + ) + assertEquals(0, server.requestJournal.unknownRequests.size) } + } - runOnPlayer { controller.pause() } - awaitCondition("pause") { !controller.isPlaying } + @Test + fun progressivePlayback_controlsAndStartPositionUseRealPlayerEvents() = run { + lateinit var probe: PlayerProbe + + step("Start progressive playback from the requested position") { + probe = prepare(FixtureId.ProgressiveMp4, startPositionMs = 1_000L) + await(probe.ready, "progressive READY") + await(probe.firstFrame, "progressive first rendered frame") + awaitCondition("non-zero start position") { + controller.currentPosition >= 900L + } + } - runOnPlayer { - controller.setSpeed(2f) - controller.seekTo(2_000L) + step("Pause playback through the production controller") { + runOnPlayer { controller.pause() } + awaitCondition("pause") { !controller.isPlaying } } - awaitCondition("forward seek") { - controller.currentPosition in 1_800L..2_400L + + step("Change speed and seek forward") { + runOnPlayer { + controller.setSpeed(2f) + controller.seekTo(2_000L) + } + awaitCondition("forward seek") { + controller.currentPosition in 1_800L..2_400L + } } - runOnPlayer { controller.play() } - awaitCondition("play after seek") { controller.isPlaying } + step("Resume playback after the forward seek") { + runOnPlayer { controller.play() } + awaitCondition("play after seek") { controller.isPlaying } + } - runOnPlayer { controller.seekTo(250L) } - awaitCondition("backward seek") { - controller.currentPosition in 0L..700L + step("Seek backward while playback remains active") { + runOnPlayer { controller.seekTo(250L) } + awaitCondition("backward seek") { + controller.currentPosition in 0L..700L + } } - runOnPlayer { controller.seekTo(3_700L) } - await(probe.ended, "near-end seek ENDED") - assertNoPlaybackError(probe) + step("Seek near the end and reach ENDED without playback errors") { + runOnPlayer { controller.seekTo(3_700L) } + await(probe.ended, "near-end seek ENDED") + assertNoPlaybackError(probe) + } - runOnPlayer { controller.play() } - awaitCondition("replay after ended") { - controller.currentPosition < 1_000L && controller.isPlaying + step("Replay from ENDED and preserve the selected speed") { + runOnPlayer { controller.play() } + awaitCondition("replay after ended") { + controller.currentPosition < 1_000L && controller.isPlaying + } + assertEquals(2f, playerRead { checkNotNull(player).getPlaybackParameters().speed }, 0f) } - assertEquals(2f, playerRead { checkNotNull(player).getPlaybackParameters().speed }, 0f) } @Test - fun awaitCondition_failsClosedWhenConditionRemainsFalse() { - val error = assertThrows(AssertionError::class.java) { - awaitCondition( - label = "deliberately false condition", - timeoutMs = FAIL_CLOSED_TIMEOUT_MS, - ) { - false + fun awaitCondition_failsClosedWhenConditionRemainsFalse() = run { + lateinit var error: AssertionError + + step("Wait on a condition that deliberately remains false") { + error = assertThrows(AssertionError::class.java) { + awaitCondition( + label = "deliberately false condition", + timeoutMs = FAIL_CLOSED_TIMEOUT_MS, + ) { + false + } } } - assertTrue(error.message.orEmpty().contains("deliberately false condition")) + step("Report the failed condition with its diagnostic label") { + assertTrue(error.message.orEmpty().contains("deliberately false condition")) + } } @Test - fun unexpectedLoopbackRequest_failsClosedWithBoundedDiagnostics() { - server.reset(emptyList()) - okhttp3.OkHttpClient().newCall( - okhttp3.Request.Builder() - .url(loopbackUrl("/unexpected-player-request")) - .build(), - ).execute().close() - server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + fun unexpectedLoopbackRequest_failsClosedWithBoundedDiagnostics() = run { + lateinit var error: AssertionError + + try { + step("Send a loopback request that has no admitted route") { + server.reset(emptyList()) + okhttp3.OkHttpClient().newCall( + okhttp3.Request.Builder() + .url(loopbackUrl("/unexpected-player-request")) + .build(), + ).execute().close() + server.awaitQuiescence(timeout = 10, unit = TimeUnit.SECONDS) + } - val error = assertThrows(AssertionError::class.java) { - server.assertNoUnknownRequests(MAX_DIAGNOSTIC_REQUESTS) + step("Reject the unknown request with bounded diagnostics") { + error = assertThrows(AssertionError::class.java) { + server.assertNoUnknownRequests(MAX_DIAGNOSTIC_REQUESTS) + } + assertTrue(error.message.orEmpty().contains("/unexpected-player-request")) + } + } finally { + server.reset(emptyList()) } - - assertTrue(error.message.orEmpty().contains("/unexpected-player-request")) - server.reset(emptyList()) } private fun prepare( diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt index 18e05597..92c8271c 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt @@ -122,242 +122,309 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa } @Test - fun hlsTracks_selectsAudioAndSubtitle_observesCueAndDisablesText() { - server.reset(commonHlsRoutes()) - val subtitleUrl = loopbackUrl("/media/subtitle.vtt?signature=test-signature") - val probe = prepare( - path = "/media/hls/master.m3u8", - subtitles = listOf( - SubtitleLink( - lang = "en", - url = subtitleUrl, + fun hlsTracks_selectsAudioAndSubtitle_observesCueAndDisablesText() = run { + lateinit var probe: PlayerProbe + lateinit var subtitleUrl: String + + step("Prepare HLS with two AAC renditions and side-loaded WebVTT") { + server.reset(commonHlsRoutes()) + subtitleUrl = loopbackUrl("/media/subtitle.vtt?signature=test-signature") + probe = prepare( + path = "/media/hls/master.m3u8", + subtitles = listOf( + SubtitleLink( + lang = "en", + url = subtitleUrl, + ), ), - ), - ) - - awaitReady(probe) - runOnPlayer { controller.pause() } - awaitCondition("both AAC renditions are exposed") { - audioTracks().map(AudioTrackUIState::language).toSet() == setOf("en", "es") + ) } - assertEquals(setOf("en", "es"), audioTracks().map(AudioTrackUIState::language).toSet()) - runOnPlayer { controller.selectAudioTrack(1) } - awaitCondition("Spanish AAC rendition selected") { - selectedAudioLanguage() == "es" + step("Reach READY and expose both AAC renditions") { + awaitReady(probe) + runOnPlayer { controller.pause() } + awaitCondition("both AAC renditions are exposed") { + audioTracks().map(AudioTrackUIState::language).toSet() == setOf("en", "es") + } + assertEquals(setOf("en", "es"), audioTracks().map(AudioTrackUIState::language).toSet()) } - val subtitle = SubtitleTrackUIState( - index = 1, - label = "English", - language = "en", - url = subtitleUrl, - ) - runOnPlayer { controller.selectSubtitle(subtitle) } - awaitCondition("side-loaded WebVTT track enabled on HLS") { - !textTracksDisabled() && selectedTextTrack() + step("Select the Spanish audio rendition") { + runOnPlayer { controller.selectAudioTrack(1) } + awaitCondition("Spanish AAC rendition selected") { + selectedAudioLanguage() == "es" + } } - assertEquals("es", selectedAudioLanguage()) - runOnPlayer { - controller.seekTo(900L) - controller.play() + + step("Select the external WebVTT track without losing audio selection") { + val subtitle = SubtitleTrackUIState( + index = 1, + label = "English", + language = "en", + url = subtitleUrl, + ) + runOnPlayer { controller.selectSubtitle(subtitle) } + awaitCondition("side-loaded WebVTT track enabled on HLS") { + !textTracksDisabled() && selectedTextTrack() + } + assertEquals("es", selectedAudioLanguage()) } - awaitCondition("fixture cue is rendered") { - probe.cueTexts.any { it.contains("Synthetic player fixture cue") } || - currentCueTexts().any { it.contains("Synthetic player fixture cue") } + + step("Render the known fixture cue and journal its subtitle request") { + runOnPlayer { + controller.seekTo(900L) + controller.play() + } + awaitCondition("fixture cue is rendered") { + probe.cueTexts.any { it.contains("Synthetic player fixture cue") } || + currentCueTexts().any { it.contains("Synthetic player fixture cue") } + } + assertTrue(server.requestJournal.entries.any { it.path == "/media/subtitle.vtt" }) } - assertTrue(server.requestJournal.entries.any { it.path == "/media/subtitle.vtt" }) - runOnPlayer { controller.selectSubtitle(null) } - awaitCondition("WebVTT track disabled") { textTracksDisabled() } - assertEquals("es", selectedAudioLanguage()) - assertEquals(0, server.requestJournal.unknownRequests.size) + step("Disable text while preserving audio and hermetic routing") { + runOnPlayer { controller.selectSubtitle(null) } + awaitCondition("WebVTT track disabled") { textTracksDisabled() } + assertEquals("es", selectedAudioLanguage()) + assertEquals(0, server.requestJournal.unknownRequests.size) + } } @Test - fun hlsPreparation_exposesCodecTracksBeforeTheFirstMediaChunkCompletes() { + fun hlsPreparation_exposesCodecTracksBeforeTheFirstMediaChunkCompletes() = run { val gate = CountDownLatch(1) - server.reset( - commonHlsRoutes( - extraRoutes = listOf( - server.route( - id = "chunkless-video-gate", - path = "/media/hls/video_720_000.ts", - response = HermeticTestServer.delayed( - gate = gate, - body = fixtureBytes("hls/video_720_000.ts"), - contentType = "video/mp2t", + lateinit var probe: PlayerProbe + + step("Block the first HLS video and audio chunks") { + server.reset( + commonHlsRoutes( + extraRoutes = listOf( + server.route( + id = "chunkless-video-gate", + path = "/media/hls/video_720_000.ts", + response = HermeticTestServer.delayed( + gate = gate, + body = fixtureBytes("hls/video_720_000.ts"), + contentType = "video/mp2t", + ), ), - ), - server.route( - id = "chunkless-audio-gate", - path = "/media/hls/audio_english_000.ts", - response = HermeticTestServer.delayed( - gate = gate, - body = fixtureBytes("hls/audio_english_000.ts"), - contentType = "video/mp2t", + server.route( + id = "chunkless-audio-gate", + path = "/media/hls/audio_english_000.ts", + response = HermeticTestServer.delayed( + gate = gate, + body = fixtureBytes("hls/audio_english_000.ts"), + contentType = "video/mp2t", + ), ), ), ), - ), - ) - val probe = prepare("/media/hls/master.m3u8") + ) + probe = prepare("/media/hls/master.m3u8") + } try { - awaitCondition("first HLS media chunks are blocked") { - server.activeRequestCount > 0 - } - awaitCondition("chunkless HLS preparation exposes CODECS tracks") { - server.activeRequestCount > 0 && playerRead { - val trackTypes = player?.currentTracks?.groups - ?.map { it.type } - .orEmpty() - C.TRACK_TYPE_VIDEO in trackTypes && C.TRACK_TYPE_AUDIO in trackTypes + step("Expose CODECS-derived audio and video tracks before chunks complete") { + awaitCondition("first HLS media chunks are blocked") { + server.activeRequestCount > 0 + } + awaitCondition("chunkless HLS preparation exposes CODECS tracks") { + server.activeRequestCount > 0 && playerRead { + val trackTypes = player?.currentTracks?.groups + ?.map { it.type } + .orEmpty() + C.TRACK_TYPE_VIDEO in trackTypes && C.TRACK_TYPE_AUDIO in trackTypes + } } } } finally { gate.countDown() } - awaitReady(probe) - assertTrue(probe.error.get() == null) - assertEquals(0, server.requestJournal.unknownRequests.size) + step("Release the chunks and complete preparation without errors") { + awaitReady(probe) + assertTrue(probe.error.get() == null) + assertEquals(0, server.requestJournal.unknownRequests.size) + } } @Test - fun hlsSwitch_preservesPositionIntentTracks_andLastStreamWins() { - server.reset(commonHlsRoutes()) - val lowUrl = loopbackUrl("/media/hls/quality-low.m3u8") - val highUrl = loopbackUrl("/media/hls/quality-high.m3u8") - val subtitleUrl = loopbackUrl("/media/subtitle.vtt?scenario=quality-switch") - val subtitle = SubtitleLink( - lang = "en", - url = subtitleUrl, - ) - val subtitleTrack = SubtitleTrackUIState(1, "English", "en", subtitleUrl) - val probe = prepare("/media/hls/quality-low.m3u8", listOf(subtitle)) + fun hlsSwitch_preservesPositionIntentTracks_andLastStreamWins() = run { + lateinit var lowUrl: String + lateinit var highUrl: String + lateinit var subtitle: SubtitleLink + lateinit var subtitleTrack: SubtitleTrackUIState + lateinit var probe: PlayerProbe + var pausedPosition = 0L + + step("Prepare the low-quality HLS source with external WebVTT") { + server.reset(commonHlsRoutes()) + lowUrl = loopbackUrl("/media/hls/quality-low.m3u8") + highUrl = loopbackUrl("/media/hls/quality-high.m3u8") + val subtitleUrl = loopbackUrl("/media/subtitle.vtt?scenario=quality-switch") + subtitle = SubtitleLink(lang = "en", url = subtitleUrl) + subtitleTrack = SubtitleTrackUIState(1, "English", "en", subtitleUrl) + probe = prepare("/media/hls/quality-low.m3u8", listOf(subtitle)) + } + + step("Select Spanish audio and WebVTT before switching quality") { + awaitReady(probe) + awaitCondition("audio tracks before switch") { audioTracks().size == 2 } + runOnPlayer { + controller.selectAudioTrack(1) + controller.selectSubtitle(subtitleTrack) + controller.seekTo(1_500L) + } + awaitCondition("position before switch") { + currentPosition() in 1_000L..2_100L + } + awaitCondition("Spanish selection before switch") { selectedAudioLanguage() == "es" } + awaitCondition("WebVTT selection before switch") { + !textTracksDisabled() && selectedTextTrack() + } + awaitCondition("WebVTT request before switch") { + server.requestJournal.entries.any { it.path == "/media/subtitle.vtt" } + } + } - awaitReady(probe) - awaitCondition("audio tracks before switch") { audioTracks().size == 2 } - runOnPlayer { - controller.selectAudioTrack(1) - controller.selectSubtitle(subtitleTrack) - controller.seekTo(1_500L) - } - awaitCondition("position before switch") { - currentPosition() in 1_000L..2_100L - } - awaitCondition("Spanish selection before switch") { selectedAudioLanguage() == "es" } - awaitCondition("WebVTT selection before switch") { - !textTracksDisabled() && selectedTextTrack() - } - awaitCondition("WebVTT request before switch") { - server.requestJournal.entries.any { it.path == "/media/subtitle.vtt" } - } - runOnPlayer { controller.pause() } - awaitCondition("paused switch source") { !isPlaying() } - val pausedPosition = currentPosition() - - runOnPlayer { controller.switchStream(highUrl, listOf(subtitle)) } - awaitCondition("high quality source prepared") { - currentMediaPath() == "/media/hls/quality-high.m3u8" && - playbackState() == Player.STATE_READY - } - assertFalse(textTracksDisabled()) - assertTrue(selectedTextTrack()) - assertFalse(isPlaying()) - assertEquals(PlaybackIntent.Paused, playbackIntent()) - assertTrue(currentPosition() in (pausedPosition - 800L)..(pausedPosition + 800L)) - awaitCondition("audio selection restored after switch") { selectedAudioLanguage() == "es" } - runOnPlayer { controller.play() } - awaitCondition("play intent restored") { - isPlaying() && playbackIntent() == PlaybackIntent.PlayRequested - } - runOnPlayer { - controller.switchStream(lowUrl, listOf(subtitle)) - controller.switchStream(highUrl, listOf(subtitle)) - controller.switchStream(lowUrl, listOf(subtitle)) - } - awaitCondition("last rapid switch wins") { - currentMediaPath() == "/media/hls/quality-low.m3u8" && - playbackIntent() == PlaybackIntent.PlayRequested - } - assertTrue(currentPosition() >= pausedPosition - 1_000L) - val masterPaths = server.requestJournal.entries - .filter { it.path.startsWith("/media/hls/quality-") } - .map { it.path } - assertTrue(masterPaths.contains("/media/hls/quality-low.m3u8")) - assertTrue(masterPaths.contains("/media/hls/quality-high.m3u8")) - assertEquals(0, server.requestJournal.unknownRequests.size) - assertTrue(probe.error.get() == null) - } + step("Pause and switch to high quality with position, intent, and tracks preserved") { + runOnPlayer { controller.pause() } + awaitCondition("paused switch source") { !isPlaying() } + pausedPosition = currentPosition() + runOnPlayer { controller.switchStream(highUrl, listOf(subtitle)) } + awaitCondition("high quality source prepared") { + currentMediaPath() == "/media/hls/quality-high.m3u8" && + playbackState() == Player.STATE_READY + } + assertFalse(textTracksDisabled()) + assertTrue(selectedTextTrack()) + assertFalse(isPlaying()) + assertEquals(PlaybackIntent.Paused, playbackIntent()) + assertTrue(currentPosition() in (pausedPosition - 800L)..(pausedPosition + 800L)) + awaitCondition("audio selection restored after switch") { + selectedAudioLanguage() == "es" + } + } - @Test - fun progressiveSwitch_restoresSelectedSubtitleAndPausedIntent() { - server.reset(commonHlsRoutes()) - val subtitleUrl = loopbackUrl("/media/subtitle.vtt") - val subtitle = SubtitleTrackUIState(1, "English", "en", subtitleUrl) - val first = prepare( - path = "/media/progressive-a.mp4", - subtitles = listOf(SubtitleLink(lang = "en", url = subtitleUrl)), - ) + step("Resume playback and let the last rapid quality switch win") { + runOnPlayer { controller.play() } + awaitCondition("play intent restored") { + isPlaying() && playbackIntent() == PlaybackIntent.PlayRequested + } + runOnPlayer { + controller.switchStream(lowUrl, listOf(subtitle)) + controller.switchStream(highUrl, listOf(subtitle)) + controller.switchStream(lowUrl, listOf(subtitle)) + } + awaitCondition("last rapid switch wins") { + currentMediaPath() == "/media/hls/quality-low.m3u8" && + playbackIntent() == PlaybackIntent.PlayRequested + } + } - awaitReady(first) - runOnPlayer { controller.pause() } - runOnPlayer { controller.selectSubtitle(subtitle) } - awaitCondition("subtitle selected before progressive switch") { - !textTracksDisabled() && selectedTextTrack() + step("Verify both quality requests and the final error-free state") { + assertTrue(currentPosition() >= pausedPosition - 1_000L) + val masterPaths = server.requestJournal.entries + .filter { it.path.startsWith("/media/hls/quality-") } + .map { it.path } + assertTrue(masterPaths.contains("/media/hls/quality-low.m3u8")) + assertTrue(masterPaths.contains("/media/hls/quality-high.m3u8")) + assertEquals(0, server.requestJournal.unknownRequests.size) + assertTrue(probe.error.get() == null) } - val positionBeforeSwitch = currentPosition() + } - val secondUrl = loopbackUrl("/media/progressive-b.mp4") - runOnPlayer { - controller.switchStream( - streamUrl = secondUrl, + @Test + fun progressiveSwitch_restoresSelectedSubtitleAndPausedIntent() = run { + lateinit var subtitleUrl: String + lateinit var subtitle: SubtitleTrackUIState + lateinit var first: PlayerProbe + var positionBeforeSwitch = 0L + + step("Prepare the first progressive source with external WebVTT") { + server.reset(commonHlsRoutes()) + subtitleUrl = loopbackUrl("/media/subtitle.vtt") + subtitle = SubtitleTrackUIState(1, "English", "en", subtitleUrl) + first = prepare( + path = "/media/progressive-a.mp4", subtitles = listOf(SubtitleLink(lang = "en", url = subtitleUrl)), ) } - awaitCondition("progressive switch completes") { - currentMediaPath() == "/media/progressive-b.mp4" && - playbackState() == Player.STATE_READY + + step("Pause and select WebVTT before the progressive switch") { + awaitReady(first) + runOnPlayer { controller.pause() } + runOnPlayer { controller.selectSubtitle(subtitle) } + awaitCondition("subtitle selected before progressive switch") { + !textTracksDisabled() && selectedTextTrack() + } + positionBeforeSwitch = currentPosition() } - assertEquals(PlaybackIntent.Paused, playbackIntent()) - assertFalse(isPlaying()) - assertTrue(currentPosition() in (positionBeforeSwitch - 800L)..(positionBeforeSwitch + 800L)) - awaitCondition("subtitle selection restored after progressive switch") { - !textTracksDisabled() && selectedTextTrack() + + step("Switch sources while preserving paused intent and position") { + val secondUrl = loopbackUrl("/media/progressive-b.mp4") + runOnPlayer { + controller.switchStream( + streamUrl = secondUrl, + subtitles = listOf(SubtitleLink(lang = "en", url = subtitleUrl)), + ) + } + awaitCondition("progressive switch completes") { + currentMediaPath() == "/media/progressive-b.mp4" && + playbackState() == Player.STATE_READY + } + assertEquals(PlaybackIntent.Paused, playbackIntent()) + assertFalse(isPlaying()) + assertTrue( + currentPosition() in + (positionBeforeSwitch - 800L)..(positionBeforeSwitch + 800L), + ) + } + + step("Restore then disable the selected subtitle on the new source") { + awaitCondition("subtitle selection restored after progressive switch") { + !textTracksDisabled() && selectedTextTrack() + } + runOnPlayer { controller.selectSubtitle(null) } + awaitCondition("subtitle disabled after progressive switch") { textTracksDisabled() } } - runOnPlayer { controller.selectSubtitle(null) } - awaitCondition("subtitle disabled after progressive switch") { textTracksDisabled() } } @Test - fun hls404AndMalformedPlaylist_failWithoutUnboundedRetry() { - runPlaylistFailure( - path = "/media/fault-404.m3u8", - response = HermeticTestServer.text( - body = "not found", - status = 404, - contentType = HLS_CONTENT_TYPE, - ), - ) - runPlaylistFailure( - path = "/media/fault-malformed.m3u8", - response = HermeticTestServer.text( - body = "this is not an HLS playlist", - contentType = HLS_CONTENT_TYPE, - ), - ) + fun hls404AndMalformedPlaylist_failWithoutUnboundedRetry() = run { + step("Fail a missing HLS playlist with a bounded request count") { + runPlaylistFailure( + path = "/media/fault-404.m3u8", + response = HermeticTestServer.text( + body = "not found", + status = 404, + contentType = HLS_CONTENT_TYPE, + ), + ) + } + step("Fail a malformed HLS playlist with a bounded request count") { + runPlaylistFailure( + path = "/media/fault-malformed.m3u8", + response = HermeticTestServer.text( + body = "this is not an HLS playlist", + contentType = HLS_CONTENT_TYPE, + ), + ) + } } @Test - fun hlsVariant400_fallsBackToTheHealthyVariant() { - assertVariantHttpFailureFallsBack(status = 400) + fun hlsVariant400_fallsBackToTheHealthyVariant() = run { + step("Fall back from one HTTP 400 variant failure to the healthy variant") { + assertVariantHttpFailureFallsBack(status = 400) + } } @Test - fun hlsVariant502_fallsBackToTheHealthyVariant() { - assertVariantHttpFailureFallsBack(status = 502) + fun hlsVariant502_fallsBackToTheHealthyVariant() = run { + step("Fall back from one HTTP 502 variant failure to the healthy variant") { + assertVariantHttpFailureFallsBack(status = 502) + } } private fun assertVariantHttpFailureFallsBack(status: Int) { @@ -398,131 +465,153 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa } @Test - fun hlsDelayedAndInterruptedSegment_enterBufferingThenRecover() { + fun hlsDelayedAndInterruptedSegment_enterBufferingThenRecover() = run { val gate = CountDownLatch(1) - server.reset( - commonHlsRoutes( - qualityLowMasterBody = singleVariantMaster("video_360.m3u8"), - video360Playlist = HermeticTestServer.text( - body = playlist(FixtureId.HlsVideo360Playlist), - contentType = HLS_CONTENT_TYPE, - ), - extraRoutes = listOf( - server.route( - id = "delayed-segment", - path = "/media/hls/video_360_000.ts", - response = HermeticTestServer.delayed( - gate = gate, - body = fixtureBytes("hls/video_360_000.ts"), - contentType = "video/mp2t", + lateinit var delayedProbe: PlayerProbe + lateinit var recoveryProbe: PlayerProbe + + step("Delay the first HLS segment and observe BUFFERING") { + server.reset( + commonHlsRoutes( + qualityLowMasterBody = singleVariantMaster("video_360.m3u8"), + video360Playlist = HermeticTestServer.text( + body = playlist(FixtureId.HlsVideo360Playlist), + contentType = HLS_CONTENT_TYPE, + ), + extraRoutes = listOf( + server.route( + id = "delayed-segment", + path = "/media/hls/video_360_000.ts", + response = HermeticTestServer.delayed( + gate = gate, + body = fixtureBytes("hls/video_360_000.ts"), + contentType = "video/mp2t", + ), ), ), ), - ), - ) - val delayedProbe = prepare("/media/hls/quality-low.m3u8") - awaitCondition("delayed segment enters BUFFERING") { - delayedProbe.stateEvents.contains(Player.STATE_BUFFERING) || - playbackState() == Player.STATE_BUFFERING + ) + delayedProbe = prepare("/media/hls/quality-low.m3u8") + awaitCondition("delayed segment enters BUFFERING") { + delayedProbe.stateEvents.contains(Player.STATE_BUFFERING) || + playbackState() == Player.STATE_BUFFERING + } } - gate.countDown() - awaitReady(delayedProbe) - assertTrue(delayedProbe.error.get() == null) - releasePlayerAndReset() - val segment = fixtureBytes("hls/video_360_000.ts") - server.reset( - commonHlsRoutes( - qualityLowMasterBody = singleVariantMaster("video_360_recovery.m3u8"), - extraRoutes = listOf( - server.route( - id = "recovery-master", - path = "/media/hls/recovery.m3u8", - response = HermeticTestServer.text( - body = singleVariantMaster("video_360_recovery.m3u8"), - contentType = HLS_CONTENT_TYPE, + step("Release the delayed segment and recover to READY") { + gate.countDown() + awaitReady(delayedProbe) + assertTrue(delayedProbe.error.get() == null) + } + + step("Replace the source with a truncated-then-ranged recovery route") { + releasePlayerAndReset() + val segment = fixtureBytes("hls/video_360_000.ts") + server.reset( + commonHlsRoutes( + qualityLowMasterBody = singleVariantMaster("video_360_recovery.m3u8"), + extraRoutes = listOf( + server.route( + id = "recovery-master", + path = "/media/hls/recovery.m3u8", + response = HermeticTestServer.text( + body = singleVariantMaster("video_360_recovery.m3u8"), + contentType = HLS_CONTENT_TYPE, + ), ), - ), - server.route( - id = "recovering-playlist", - path = "/media/hls/video_360_recovery.m3u8", - response = HermeticTestServer.text( - body = playlist(FixtureId.HlsVideo360Playlist) - .replace("video_360_", "video_360_recovery_"), - contentType = HLS_CONTENT_TYPE, + server.route( + id = "recovering-playlist", + path = "/media/hls/video_360_recovery.m3u8", + response = HermeticTestServer.text( + body = playlist(FixtureId.HlsVideo360Playlist) + .replace("video_360_", "video_360_recovery_"), + contentType = HLS_CONTENT_TYPE, + ), ), - ), - server.route( - id = "recovering-segment", - path = "/media/hls/video_360_recovery_000.ts", - response = HermeticTestServer.sequence( - HermeticTestServer.truncated( - body = segment, - bytesToWrite = segment.size / 4, - contentType = "video/mp2t", + server.route( + id = "recovering-segment", + path = "/media/hls/video_360_recovery_000.ts", + response = HermeticTestServer.sequence( + HermeticTestServer.truncated( + body = segment, + bytesToWrite = segment.size / 4, + contentType = "video/mp2t", + ), + HermeticTestServer.bytes(segment, contentType = "video/mp2t"), ), - HermeticTestServer.bytes(segment, contentType = "video/mp2t"), ), - ), - server.route( - id = "recovering-segment-1", - path = "/media/hls/video_360_recovery_001.ts", - response = HermeticTestServer.bytes( - fixtureBytes("hls/video_360_001.ts"), - contentType = "video/mp2t", + server.route( + id = "recovering-segment-1", + path = "/media/hls/video_360_recovery_001.ts", + response = HermeticTestServer.bytes( + fixtureBytes("hls/video_360_001.ts"), + contentType = "video/mp2t", + ), ), ), ), - ), - ) - val recoveryProbe = prepare("/media/hls/recovery.m3u8") - awaitReady(recoveryProbe) - val recoveryEntries = server.requestJournal.entries.filter { - it.routeId == "recovering-segment" + ) + recoveryProbe = prepare("/media/hls/recovery.m3u8") + } + + step("Recover the interrupted segment with a ranged second request") { + awaitReady(recoveryProbe) + val recoveryEntries = server.requestJournal.entries.filter { + it.routeId == "recovering-segment" + } + assertTrue( + "Expected interrupted segment recovery; entries=$recoveryEntries", + recoveryEntries.size >= 2, + ) + assertEquals(200, (recoveryEntries[0].outcome as ResponseOutcome.Completed).status) + assertEquals(200, (recoveryEntries[1].outcome as ResponseOutcome.Completed).status) + assertTrue( + "Expected a ranged recovery request; entries=$recoveryEntries", + recoveryEntries[1].range != null, + ) + assertTrue(recoveryProbe.error.get() == null) + assertEquals(0, server.requestJournal.unknownRequests.size) } - assertTrue( - "Expected interrupted segment recovery; entries=$recoveryEntries", - recoveryEntries.size >= 2, - ) - assertEquals(200, (recoveryEntries[0].outcome as ResponseOutcome.Completed).status) - assertEquals(200, (recoveryEntries[1].outcome as ResponseOutcome.Completed).status) - assertTrue( - "Expected a ranged recovery request; entries=$recoveryEntries", - recoveryEntries[1].range != null, - ) - assertTrue(recoveryProbe.error.get() == null) - assertEquals(0, server.requestJournal.unknownRequests.size) } @Test - fun playerMediaNetworkIsolation_rejectsExternalRedirectAndSanitizesViolation() { - server.reset( - listOf( - server.route( - id = "external-redirect", - path = "/media/redirect.m3u8", - response = HermeticTestServer.redirect( - "https://redirect-user:redirect-password@example.com/blocked" + - "?token=must-not-be-recorded", + fun playerMediaNetworkIsolation_rejectsExternalRedirectAndSanitizesViolation() = run { + lateinit var probe: PlayerProbe + + step("Prepare an HLS redirect to a blocked external origin") { + server.reset( + listOf( + server.route( + id = "external-redirect", + path = "/media/redirect.m3u8", + response = HermeticTestServer.redirect( + "https://redirect-user:redirect-password@example.com/blocked" + + "?token=must-not-be-recorded", + ), ), ), - ), - ) - val probe = prepare("/media/redirect.m3u8") + ) + probe = prepare("/media/redirect.m3u8") + } - awaitCondition("external redirect fails locally") { probe.error.get() != null } - awaitCondition("one external violation is journaled") { - LoopbackNetworkJournal(context).snapshot().size == 1 + step("Fail the external redirect locally and journal one violation") { + awaitCondition("external redirect fails locally") { probe.error.get() != null } + awaitCondition("one external violation is journaled") { + LoopbackNetworkJournal(context).snapshot().size == 1 + } } + try { - val violations = LoopbackNetworkJournal(context).snapshot() - assertEquals(1, violations.size) - assertTrue(violations.single().startsWith("https://example.com:443")) - assertFalse(violations.single().contains("redirect-user")) - assertFalse(violations.single().contains("redirect-password")) - assertFalse(violations.single().contains("token")) - assertFalse(violations.single().contains("?")) - assertEquals(0, server.requestJournal.unknownRequests.size) + step("Sanitize credentials, query data, and user info from the violation") { + val violations = LoopbackNetworkJournal(context).snapshot() + assertEquals(1, violations.size) + assertTrue(violations.single().startsWith("https://example.com:443")) + assertFalse(violations.single().contains("redirect-user")) + assertFalse(violations.single().contains("redirect-password")) + assertFalse(violations.single().contains("token")) + assertFalse(violations.single().contains("?")) + assertEquals(0, server.requestJournal.unknownRequests.size) + } } finally { LoopbackNetworkJournal(context).clear() } diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt index d838c2b5..6f07f47c 100644 --- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt +++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt @@ -118,202 +118,275 @@ internal class PlaybackControllerResourcesTest : PlayerInstrumentationTestCase() } @Test - fun progressiveReplay_readsCommittedCacheAfterUpstreamRouteIsRemoved() { - server.reset(progressiveRoutes()) - val url = loopbackUrl("/media/progressive.mp4") - val first = prepare(url) - - awaitReady(first) - await(first.ended, "initial playback ended", first) - val cachedBytes = cache.getCachedBytes(url, 0L, C.LENGTH_UNSET.toLong()) - assertTrue("Expected committed media bytes, got $cachedBytes", cachedBytes > 0L) - releaseController(first) + fun progressiveReplay_readsCommittedCacheAfterUpstreamRouteIsRemoved() = run { + lateinit var url: String + lateinit var first: PlayerProbe + lateinit var replay: PlayerProbe - server.reset(emptyList()) - val replay = prepare(url) - awaitReady(replay) - runOnActivity { - controller.pause() - controller.seekTo(CACHED_REPLAY_SEEK_POSITION_MS) + step("Play the progressive fixture through to committed cache") { + server.reset(progressiveRoutes()) + url = loopbackUrl("/media/progressive.mp4") + first = prepare(url) + awaitReady(first) + await(first.ended, "initial playback ended", first) + val cachedBytes = cache.getCachedBytes(url, 0L, C.LENGTH_UNSET.toLong()) + assertTrue("Expected committed media bytes, got $cachedBytes", cachedBytes > 0L) + releaseController(first) + } + + step("Replay from cache after removing the upstream route") { + server.reset(emptyList()) + replay = prepare(url) + awaitReady(replay) + runOnActivity { + controller.pause() + controller.seekTo(CACHED_REPLAY_SEEK_POSITION_MS) + } + awaitCondition("cached replay seek crosses the position fence", replay) { + playbackState() == Player.STATE_READY && + !isPlaying() && + currentPosition() in CACHED_REPLAY_SEEK_POSITION_MS.. + CACHED_REPLAY_SEEK_FENCE_END_MS + } } - awaitCondition("cached replay seek crosses the position fence", replay) { - playbackState() == Player.STATE_READY && - !isPlaying() && - currentPosition() in CACHED_REPLAY_SEEK_POSITION_MS.. - CACHED_REPLAY_SEEK_FENCE_END_MS + + step("Verify the cached seek is error-free and makes no upstream request") { + assertTrue( + "Cached replay seek should not request a removed upstream route: " + + server.requestJournal.entries, + server.requestJournal.entries.isEmpty(), + ) + assertNull("Cached replay seek reported a playback error", replay.error.get()) + releaseController(replay) + assertResourcesQuiescent("cached replay seek", replay) } - assertTrue( - "Cached replay seek should not request a removed upstream route: " + - server.requestJournal.entries, - server.requestJournal.entries.isEmpty(), - ) - assertNull("Cached replay seek reported a playback error", replay.error.get()) - releaseController(replay) - assertResourcesQuiescent("cached replay seek", replay) } @Test - fun emptyCache_loadsNormally_andCorruptOwnedEntryRecoversWithoutPoisoningNextScenario() { + fun emptyCache_loadsNormally_andCorruptOwnedEntryRecoversWithoutPoisoningNextScenario() = run { val url = loopbackUrl("/media/progressive.mp4") - server.reset(progressiveRoutes()) - val miss = prepare(url) + lateinit var corrupt: PlayerProbe + lateinit var clean: PlayerProbe - awaitReady(miss) - assertTrue( - "Empty cache should use loopback upstream", - server.requestJournal.entries.any { it.path == "/media/progressive.mp4" }, - ) - releaseController(miss) + step("Load an empty cache from the loopback upstream") { + server.reset(progressiveRoutes()) + val miss = prepare(url) + awaitReady(miss) + assertTrue( + "Empty cache should use loopback upstream", + server.requestJournal.entries.any { it.path == "/media/progressive.mp4" }, + ) + releaseController(miss) + } - cache.removeResource(url) - writeCorruptCacheEntry(url) - server.reset(progressiveRoutes()) - val corrupt = prepare(url) - awaitReadyOrError(corrupt) - assertTrue( - "Corrupt cache must produce a controlled recovery or error: ${diagnostics(corrupt)}", - corrupt.ready.count == 0L || corrupt.error.get() != null, - ) - releaseController(corrupt) - - cache.removeResource(url) - assertTrue(cache.getCachedSpans(url).isEmpty()) - server.reset(progressiveRoutes()) - val clean = prepare(url) - awaitReady(clean) - assertNull(clean.error.get()) - assertTrue( - "Clean scenario should load after corrupt entry cleanup", - server.requestJournal.entries.any { it.path == "/media/progressive.mp4" }, - ) - releaseController(clean) - assertResourcesQuiescent("clean post-corruption scenario", clean) + step("Handle a corrupt owned cache entry with a controlled outcome") { + cache.removeResource(url) + writeCorruptCacheEntry(url) + server.reset(progressiveRoutes()) + corrupt = prepare(url) + awaitReadyOrError(corrupt) + assertTrue( + "Corrupt cache must produce a controlled recovery or error: ${diagnostics(corrupt)}", + corrupt.ready.count == 0L || corrupt.error.get() != null, + ) + releaseController(corrupt) + } + + step("Clean the corrupt entry and prove the next playback is not poisoned") { + cache.removeResource(url) + assertTrue(cache.getCachedSpans(url).isEmpty()) + server.reset(progressiveRoutes()) + clean = prepare(url) + awaitReady(clean) + assertNull(clean.error.get()) + assertTrue( + "Clean scenario should load after corrupt entry cleanup", + server.requestJournal.entries.any { it.path == "/media/progressive.mp4" }, + ) + releaseController(clean) + assertResourcesQuiescent("clean post-corruption scenario", clean) + } } @Test - fun lifecycle_detachReattach_backgroundForegroundAndRecreation_keepPlayerUsable() { - server.reset(progressiveRoutes()) - val url = loopbackUrl("/media/progressive.mp4") - val probe = prepare(url) + fun lifecycle_detachReattach_backgroundForegroundAndRecreation_keepPlayerUsable() = run { + lateinit var probe: PlayerProbe - awaitReady(probe) - runOnActivity { playerView.player = null } - assertNull(playerRead { playerView.player }) - runOnActivity { playerView.player = controller.player } - assertNotNull(playerRead { playerView.player }) - awaitCondition("reattached player remains ready", probe) { - playbackState() == Player.STATE_READY + step("Prepare progressive playback for lifecycle transitions") { + server.reset(progressiveRoutes()) + probe = prepare(loopbackUrl("/media/progressive.mp4")) + awaitReady(probe) } - scenario.moveToState(Lifecycle.State.CREATED) - scenario.moveToState(Lifecycle.State.RESUMED) - attachPlayerView() - assertNotNull(playerRead { playerView.player }) - awaitCondition("foreground player remains ready", probe) { - playbackState() == Player.STATE_READY + step("Detach and reattach the PlayerView without losing READY") { + runOnActivity { playerView.player = null } + assertNull(playerRead { playerView.player }) + runOnActivity { playerView.player = controller.player } + assertNotNull(playerRead { playerView.player }) + awaitCondition("reattached player remains ready", probe) { + playbackState() == Player.STATE_READY + } } - scenario.recreate() - attachPlayerView() - assertNotNull(playerRead { playerView.player }) - awaitCondition("recreated activity receives the player", probe) { - playbackState() == Player.STATE_READY + step("Background and foreground the host while retaining the player") { + scenario.moveToState(Lifecycle.State.CREATED) + scenario.moveToState(Lifecycle.State.RESUMED) + attachPlayerView() + assertNotNull(playerRead { playerView.player }) + awaitCondition("foreground player remains ready", probe) { + playbackState() == Player.STATE_READY + } } - assertTrue("Player diagnostics were unexpectedly empty", diagnostics(probe).isNotBlank()) - releaseController(probe) - assertResourcesQuiescent("activity recreation", probe) + step("Recreate the activity and restore the PlayerView attachment") { + scenario.recreate() + attachPlayerView() + assertNotNull(playerRead { playerView.player }) + awaitCondition("recreated activity receives the player", probe) { + playbackState() == Player.STATE_READY + } + assertTrue("Player diagnostics were unexpectedly empty", diagnostics(probe).isNotBlank()) + } + + step("Release recreated playback with no retained resources") { + releaseController(probe) + assertResourcesQuiescent("activity recreation", probe) + } } @Test - fun progressiveDecode_reportsMandatoryCapabilitiesDecodersCountersAndAnalytics() { - val capabilities = CodecCapabilityReport.capture() - assertTrue( - "H.264 decoder is mandatory; ${capabilities.boundedSummary()}", - capabilities.h264Decoders.isNotEmpty(), - ) - assertTrue( - "AAC decoder is mandatory; ${capabilities.boundedSummary()}", - capabilities.aacDecoders.isNotEmpty(), - ) + fun progressiveDecode_reportsMandatoryCapabilitiesDecodersCountersAndAnalytics() = run { + lateinit var probe: PlayerProbe + + step("Require H.264 and AAC decoder capabilities on the emulator") { + val capabilities = CodecCapabilityReport.capture() + assertTrue( + "H.264 decoder is mandatory; ${capabilities.boundedSummary()}", + capabilities.h264Decoders.isNotEmpty(), + ) + assertTrue( + "AAC decoder is mandatory; ${capabilities.boundedSummary()}", + capabilities.aacDecoders.isNotEmpty(), + ) + } + + step("Decode the progressive fixture and collect real decoder activity") { + server.reset(progressiveRoutes()) + probe = prepare(loopbackUrl("/media/progressive.mp4")) + awaitReady(probe) + await(probe.firstFrame, "first frame", probe) + awaitCondition("H.264/AAC decoder diagnostics", probe) { + val snapshot = decoderSnapshot() + snapshot.videoMimeType == MimeTypes.VIDEO_H264 && + snapshot.audioMimeType == MimeTypes.AUDIO_AAC && + snapshot.videoDecoderInitCount > 0 && + snapshot.audioDecoderInitCount > 0 && + snapshot.videoQueuedInputBuffers > 0 && + snapshot.audioQueuedInputBuffers > 0 && + snapshot.renderedVideoBuffers > 0 && + probe.analytics.videoDecoderName.get() != null && + probe.analytics.audioDecoderName.get() != null + } + } - server.reset(progressiveRoutes()) - val probe = prepare(loopbackUrl("/media/progressive.mp4")) - awaitReady(probe) - await(probe.firstFrame, "first frame", probe) - awaitCondition("H.264/AAC decoder diagnostics", probe) { + step("Verify formats, decoder counters, and bounded analytics") { val snapshot = decoderSnapshot() - snapshot.videoMimeType == MimeTypes.VIDEO_H264 && - snapshot.audioMimeType == MimeTypes.AUDIO_AAC && - snapshot.videoDecoderInitCount > 0 && - snapshot.audioDecoderInitCount > 0 && - snapshot.videoQueuedInputBuffers > 0 && - snapshot.audioQueuedInputBuffers > 0 && - snapshot.renderedVideoBuffers > 0 && - probe.analytics.videoDecoderName.get() != null && - probe.analytics.audioDecoderName.get() != null - } - - val snapshot = decoderSnapshot() - assertEquals(MimeTypes.VIDEO_H264, snapshot.videoMimeType) - assertEquals(MimeTypes.AUDIO_AAC, snapshot.audioMimeType) - assertTrue("Video decoder counters were empty: $snapshot", snapshot.videoQueuedInputBuffers > 0) - assertTrue("Audio decoder counters were empty: $snapshot", snapshot.audioQueuedInputBuffers > 0) - assertTrue("No video frame was rendered: $snapshot", snapshot.renderedVideoBuffers > 0) - assertTrue("Unexpected analytics load errors: ${probe.analytics.boundedEvents()}", probe.analytics.loadErrors.isEmpty()) - assertTrue("Unexpected analytics player errors: ${probe.analytics.boundedEvents()}", probe.analytics.playerErrors.isEmpty()) - - releaseController(probe) - assertResourcesQuiescent("mandatory codec diagnostics", probe) + assertEquals(MimeTypes.VIDEO_H264, snapshot.videoMimeType) + assertEquals(MimeTypes.AUDIO_AAC, snapshot.audioMimeType) + assertTrue( + "Video decoder counters were empty: $snapshot", + snapshot.videoQueuedInputBuffers > 0, + ) + assertTrue( + "Audio decoder counters were empty: $snapshot", + snapshot.audioQueuedInputBuffers > 0, + ) + assertTrue("No video frame was rendered: $snapshot", snapshot.renderedVideoBuffers > 0) + assertTrue( + "Unexpected analytics load errors: ${probe.analytics.boundedEvents()}", + probe.analytics.loadErrors.isEmpty(), + ) + assertTrue( + "Unexpected analytics player errors: ${probe.analytics.boundedEvents()}", + probe.analytics.playerErrors.isEmpty(), + ) + } + + step("Release decoded playback with no resource ownership retained") { + releaseController(probe) + assertResourcesQuiescent("mandatory codec diagnostics", probe) + } } @Test - fun releaseDuringBlockedLoad_closesRequestsAndDetachesReleasedView() { + fun releaseDuringBlockedLoad_closesRequestsAndDetachesReleasedView() = run { val gate = CountDownLatch(1) responseGate = gate val url = loopbackUrl("/media/blocked.mp4") - server.reset( - listOf( - server.route( - id = "blocked", - path = "/media/blocked.mp4", - response = HermeticTestServer.delayed( - gate = gate, - body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), - contentType = "video/mp4", + lateinit var probe: PlayerProbe + + step("Start a progressive request blocked by the fixture gate") { + server.reset( + listOf( + server.route( + id = "blocked", + path = "/media/blocked.mp4", + response = HermeticTestServer.delayed( + gate = gate, + body = PlayerTestFixtures.readBytes(FixtureId.ProgressiveMp4, context), + contentType = "video/mp4", + ), ), ), - ), - ) - val probe = prepare(url) - awaitCondition("blocked request starts", probe) { - server.activeRequestCount > 0 + ) + probe = prepare(url) + awaitCondition("blocked request starts", probe) { + server.activeRequestCount > 0 + } } - releaseController(probe, awaitRequests = false) - gate.countDown() - assertResourcesQuiescent("release during blocked load", probe) - assertTrue("Stale callback reported an error: ${probe.error.get()}", probe.error.get() == null) + step("Release during the blocked load and detach the PlayerView") { + releaseController(probe, awaitRequests = false) + gate.countDown() + } + + step("Drain the request without stale callbacks or retained resources") { + assertResourcesQuiescent("release during blocked load", probe) + assertTrue( + "Stale callback reported an error: ${probe.error.get()}", + probe.error.get() == null, + ) + } } @Test - fun boundedPreparePlaySeekReleaseLoop_leavesNoActiveRequestsOrOpenSpans() { + fun boundedPreparePlaySeekReleaseLoop_leavesNoActiveRequestsOrOpenSpans() = run { val url = loopbackUrl("/media/progressive.mp4") repeat(STRESS_ITERATIONS) { iteration -> - server.reset(progressiveRoutes()) - val probe = prepare(url) - awaitReady(probe) - runOnActivity { - controller.pause() - controller.seekTo(350L) - controller.play() + lateinit var probe: PlayerProbe + + step("Prepare stress iteration ${iteration + 1}") { + server.reset(progressiveRoutes()) + probe = prepare(url) + awaitReady(probe) + } + + step("Play and seek stress iteration ${iteration + 1}") { + runOnActivity { + controller.pause() + controller.seekTo(350L) + controller.play() + } + awaitCondition("stress iteration $iteration advances", probe) { + currentPosition() >= 300L + } + assertNull(probe.error.get()) } - awaitCondition("stress iteration $iteration advances", probe) { - currentPosition() >= 300L + + step("Release stress iteration ${iteration + 1} without leaked resources") { + releaseController(probe) + assertResourcesQuiescent("stress iteration $iteration", probe) } - assertNull(probe.error.get()) - releaseController(probe) - assertResourcesQuiescent("stress iteration $iteration", probe) } } diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/AudioSubtitlesPanel.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/AudioSubtitlesPanel.kt index d4a56fe9..26485d61 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/AudioSubtitlesPanel.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/AudioSubtitlesPanel.kt @@ -174,6 +174,7 @@ private fun RowScope.SoundModeColumn( onItemSelected = onSoundModeSelected, modifier = Modifier.weight(1f), firstItemFocusRequester = panelFocusRequester, + itemTestTag = { index -> PlayerScreenTestTags.panelItem("sound", index) }, ) } @@ -193,6 +194,7 @@ private fun RowScope.AudioTrackColumn( onItemSelected = onAudioTrackSelected, modifier = Modifier.weight(1f), firstItemFocusRequester = panelFocusRequester, + itemTestTag = { index -> PlayerScreenTestTags.panelItem("audio", index) }, ) } @@ -211,6 +213,7 @@ private fun RowScope.SubtitleColumn( onItemSelected = onSubtitleSelected, modifier = Modifier.weight(1f), firstItemFocusRequester = panelFocusRequester, + itemTestTag = { index -> PlayerScreenTestTags.panelItem("subtitle", index) }, ) } diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/NextEpisodeOverlay.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/NextEpisodeOverlay.kt index 05b43947..33bea9a4 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/NextEpisodeOverlay.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/NextEpisodeOverlay.kt @@ -26,6 +26,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource import androidx.compose.ui.unit.dp import androidx.tv.material3.Button @@ -122,7 +123,9 @@ private fun NextEpisodeButton( Surface( onClick = onClick, - modifier = Modifier.focusRequester(focusRequester), + modifier = Modifier + .testTag(PlayerScreenTestTags.NextEpisode) + .focusRequester(focusRequester), shape = androidx.tv.material3.ClickableSurfaceDefaults.shape(shape = shape), colors = androidx.tv.material3.ClickableSurfaceDefaults.colors( containerColor = MaterialTheme.colorScheme.surface.copy(alpha = 0.8f), diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt index 47b360a6..6b09d5a5 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerButtonRow.kt @@ -93,6 +93,7 @@ private fun PrimaryControls( PhosphorIcons.Duotone.Eye }, onClick = actions.onMarkCurrentWatchedClick, + modifier = Modifier.testTag(PlayerScreenTestTags.MarkWatched), selected = state.isCurrentMediaWatched, enabled = !state.isMarkCurrentWatchedInFlight, stateDescription = stringResource( @@ -109,20 +110,26 @@ private fun PrimaryControls( text = stringResource(R.string.player_button_episodes), icon = Icons.AutoMirrored.Filled.PlaylistPlay, onClick = actions.onEpisodesClick, - modifier = Modifier.focusRequester(focusRequesters.episodesButton), + modifier = Modifier + .testTag(PlayerScreenTestTags.Episodes) + .focusRequester(focusRequesters.episodesButton), ) } PlayerButton( text = stringResource(R.string.player_button_audio_subtitles), icon = Icons.Default.Subtitles, onClick = actions.onAudioSubtitlesClick, - modifier = Modifier.focusRequester(focusRequesters.audioSubtitlesButton), + modifier = Modifier + .testTag(PlayerScreenTestTags.AudioSubtitles) + .focusRequester(focusRequesters.audioSubtitlesButton), ) PlayerButton( text = stringResource(R.string.player_button_video), icon = Icons.Default.Videocam, onClick = actions.onVideoSettingsClick, - modifier = Modifier.focusRequester(focusRequesters.videoSettingsButton), + modifier = Modifier + .testTag(PlayerScreenTestTags.VideoSettings) + .focusRequester(focusRequesters.videoSettingsButton), ) } } diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt index db079d82..0f4b57bc 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerScreenContent.kt @@ -239,6 +239,15 @@ internal object PlayerScreenTestTags { const val Surface = "player_surface" const val PlayPause = "player_play_pause" const val SeekBar = "player_seek_bar" + const val MarkWatched = "player_mark_watched" + const val Episodes = "player_episodes" + const val AudioSubtitles = "player_audio_subtitles" + const val VideoSettings = "player_video_settings" + const val ResumeContinue = "player_resume_continue" + const val Retry = "player_retry" + const val NextEpisode = "player_next_episode" + + fun panelItem(group: String, index: Int): String = "player_panel_${group}_$index" } private fun handlePlayerKeyEvent( @@ -315,7 +324,9 @@ private fun ErrorOverlay( ErrorButton( text = stringResource(R.string.player_error_retry), onClick = onRetry, - modifier = Modifier.focusRequester(retryFocusRequester), + modifier = Modifier + .testTag(PlayerScreenTestTags.Retry) + .focusRequester(retryFocusRequester), primary = true, ) ErrorButton( diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/ResumeDialog.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/ResumeDialog.kt index e2b06e3f..310d73a7 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/ResumeDialog.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/ResumeDialog.kt @@ -17,6 +17,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource import androidx.compose.ui.unit.dp import androidx.tv.material3.Button @@ -123,7 +124,9 @@ private fun ResumeActions( Row(horizontalArrangement = Arrangement.spacedBy(ACTION_SPACING)) { Button( onClick = onResume, - modifier = Modifier.focusRequester(resumeButtonFocusRequester), + modifier = Modifier + .testTag(PlayerScreenTestTags.ResumeContinue) + .focusRequester(resumeButtonFocusRequester), ) { Text(text = stringResource(R.string.player_resume_continue)) } diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/SettingsPanelColumn.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/SettingsPanelColumn.kt index 3e93e55e..90b1250d 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/SettingsPanelColumn.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/SettingsPanelColumn.kt @@ -18,6 +18,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.testTag import androidx.compose.ui.unit.dp import androidx.tv.material3.ClickableSurfaceDefaults import androidx.tv.material3.Icon @@ -33,6 +34,7 @@ internal fun SettingsPanelColumn( onItemSelected: (Int) -> Unit, modifier: Modifier = Modifier, firstItemFocusRequester: FocusRequester? = null, + itemTestTag: ((Int) -> String)? = null, ) { val primaryColor = MaterialTheme.colorScheme.primary val onSurfaceColor = MaterialTheme.colorScheme.onSurface @@ -58,6 +60,7 @@ internal fun SettingsPanelColumn( text = item, selected = index == selectedIndex, focusRequester = firstItemFocusRequester.takeIf { index == 0 }, + testTag = itemTestTag?.invoke(index), colors = SettingsPanelItemColors( primary = primaryColor, onSurface = onSurfaceColor, @@ -79,12 +82,15 @@ private fun SettingsPanelItem( text: String, selected: Boolean, focusRequester: FocusRequester?, + testTag: String?, colors: SettingsPanelItemColors, onClick: () -> Unit, ) { Surface( onClick = onClick, - modifier = focusRequester?.let { Modifier.focusRequester(it) } ?: Modifier, + modifier = Modifier + .then(testTag?.let { Modifier.testTag(it) } ?: Modifier) + .then(focusRequester?.let { Modifier.focusRequester(it) } ?: Modifier), colors = ClickableSurfaceDefaults.colors( containerColor = Color.Transparent, focusedContainerColor = colors.primary.copy(alpha = 0.2f), diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/VideoSettingsPanel.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/VideoSettingsPanel.kt index 423f1cda..3fe9c7dc 100644 --- a/app/src/main/java/com/kino/puber/ui/feature/player/component/VideoSettingsPanel.kt +++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/VideoSettingsPanel.kt @@ -183,6 +183,7 @@ private fun ColumnScope.VideoSettingsColumns( firstItemFocusRequester = panelFocusRequester.takeIf { initialFocusTarget == VideoSettingsFocusTarget.Speed }, + itemTestTag = { index -> PlayerScreenTestTags.panelItem("speed", index) }, ) SettingsPanelColumn( header = stringResource(R.string.player_panel_aspect_ratio), @@ -193,6 +194,7 @@ private fun ColumnScope.VideoSettingsColumns( firstItemFocusRequester = panelFocusRequester.takeIf { initialFocusTarget == VideoSettingsFocusTarget.AspectRatio }, + itemTestTag = { index -> PlayerScreenTestTags.panelItem("aspect", index) }, ) SettingsPanelColumn( header = stringResource(R.string.player_panel_buffer), @@ -203,6 +205,7 @@ private fun ColumnScope.VideoSettingsColumns( firstItemFocusRequester = panelFocusRequester.takeIf { initialFocusTarget == VideoSettingsFocusTarget.Buffer }, + itemTestTag = { index -> PlayerScreenTestTags.panelItem("buffer", index) }, ) } } @@ -221,6 +224,7 @@ private fun RowScope.QualityColumn( onItemSelected = onQualitySelected, modifier = Modifier.weight(1f), firstItemFocusRequester = panelFocusRequester, + itemTestTag = { index -> PlayerScreenTestTags.panelItem("quality", index) }, ) } diff --git a/docs/testing/player-playback.md b/docs/testing/player-playback.md index a1887d31..6c1ab105 100644 --- a/docs/testing/player-playback.md +++ b/docs/testing/player-playback.md @@ -11,8 +11,8 @@ stream. | --- | --- | --- | | Fixture integrity | `:player-test-fixtures:test` and its Android test | The same committed bytes, metadata, playlist references, rendition labels, and WebVTT cue are available to JVM and Android tests. | | Host policy/state | `:app:testDevDebugUnitTest` and `:app:testProdDebugUnitTest`, filtered to `com.kino.puber.ui.feature.player.vm.*` | HLS error policy, subtitle MIME and identity, audio/subtitle preference matching, AC3 fallback state, VM transitions, and generation guards. | -| Real player instrumentation | `PlaybackControllerDeviceTest`, `PlaybackControllerNetworkTracksTest`, and `PlaybackControllerResourcesTest` | The production `PlaybackController` and Media3 player load loopback MP4/HLS, render on a real `PlayerView`, select tracks/cues, recover from programmed faults, and release cleanly. | -| Production-screen instrumentation | `PlayerScreenContentFocusTest`, `PlayerScreenE2ETest`, and `PlayerVideoSurfaceTest` | The production screen/Koin scope handles real media, concrete TV focus, D-pad/media/back events, lifecycle progress saves, resume, series episode identity, and surface ownership. | +| Technical player instrumentation | `PlaybackControllerDeviceTest`, `PlaybackControllerNetworkTracksTest`, `PlaybackControllerResourcesTest`, and `PlayerVideoSurfaceTest` | The production `PlaybackController`, Media3 player, `PlayerView`, and `PlayerVideoSurface` load loopback MP4/HLS, select tracks/cues, recover from programmed faults, release cleanly, and enforce technical surface/window ownership. | +| Compose UI instrumentation | `PlayerScreenContentFocusTest` and `PlayerScreenE2ETest` | The production player UI handles concrete TV focus and D-pad/media/back events; the end-to-end class additionally launches the real `PlayerScreen`/Koin scope to prove media, lifecycle progress saves, resume, and series episode identity. | The instrumentation tests use a per-test `SimpleCache`, unique scenario identities, event/latch/player fences instead of `Thread.sleep`, and bounded @@ -20,12 +20,18 @@ failure diagnostics. Teardown waits for zero active server requests, releases the player and surface, removes only test-owned cache state, and fails on unknown or external-origin requests. -All six player instrumentation classes share -`PlayerInstrumentationTestCase`, so each JUnit scenario is reported as a named -Kaspresso step. Production `PlayerScreen` journeys use `PlayerComposeScreen` -and the minimal stable player-only test tags. Controller, Media3, network, -cache, lifecycle, codec, request-journal, and resource assertions remain -direct and event-based inside those steps. +The four technical classes use `PlayerInstrumentationTestCase` with +`Kaspresso.Builder.simple()`. `PlayerScreenContentFocusTest` and +`PlayerScreenE2ETest` use `PlayerComposeInstrumentationTestCase` with +`Kaspresso.Builder.withComposeSupport()`. `PlayerVideoSurfaceTest` is technical +`PlayerVideoSurface`/window-ownership coverage, not a production +`PlayerScreen`/Koin journey. + +Every test method directly owns its Kaspresso `run` block and its meaningful +named `step(...)` narrative. The Compose UI tests use the player screen/robot +abstractions and minimal stable player-only test tags. Controller, Media3, +network, cache, lifecycle, codec, request-journal, resource, and surface +assertions remain direct and event-based inside their owning steps. ## Fixture pack and provenance diff --git a/player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt b/player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt index 76ddf853..b1110fdd 100644 --- a/player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt +++ b/player-test-fixtures/src/androidTest/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesAndroidTest.kt @@ -12,16 +12,14 @@ class PlayerTestFixturesAndroidTest { @Test fun packagedAndroidAsset_isTheSameCommittedFixture() { val context = InstrumentationRegistry.getInstrumentation().context + val checksums = PlayerTestFixtures.committedChecksums(context) - FixtureId.entries.forEach { fixture -> + assertTrue("fixture checksum manifest is missing", checksums.isNotEmpty()) + checksums.forEach { (path, expected) -> assertTrue( - "$fixture is missing or changed in Android assets", - PlayerTestFixtures.verifySha256(fixture, context), + "$path is missing or changed in packaged Android assets", + PlayerTestFixtures.verifySha256(path, expected, context), ) } - assertTrue( - "fixture checksum manifest is missing", - PlayerTestFixtures.committedChecksums(context).isNotEmpty(), - ) } } diff --git a/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt index a59c9ec2..5e5d42a3 100644 --- a/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt +++ b/player-test-fixtures/src/main/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixtures.kt @@ -19,6 +19,7 @@ object PlayerTestFixtures { private const val ROOT = "player-fixtures" private const val MANIFEST = "$ROOT/fixture-manifest.properties" private const val SHA256SUMS = "$ROOT/SHA256SUMS" + private val checksumLine = Regex("([0-9a-f]{64}) {2}([^\\s]+)") val catalog: FixtureCatalog by lazy { FixtureCatalog(loadProperties()) } @@ -43,20 +44,45 @@ object PlayerTestFixtures { fun verifySha256(fixture: FixtureId, context: Context? = null): Boolean { val expected = (context?.let(::catalog) ?: catalog).metadata(fixture).sha256 + return verifySha256(fixture.path, expected, context) + } + + fun verifySha256( + path: String, + expected: String, + context: Context? = null, + ): Boolean { + require(expected.matches(Regex("[0-9a-f]{64}"))) { + "Expected SHA-256 must be 64 lowercase hexadecimal characters" + } val actual = MessageDigest.getInstance("SHA-256") - .digest(readBytes(fixture, context)) + .digest(openPath(path, context).use(InputStream::readBytes)) .toHex() return actual == expected } fun committedChecksums(context: Context? = null): Map = - openPath(SHA256SUMS.removePrefix("$ROOT/"), context).bufferedReader().useLines { lines -> - lines - .filter { it.isNotBlank() && !it.startsWith("#") } - .associate { line -> - val (hash, path) = line.split(Regex("\\s+"), limit = 2) - path to hash + openPath(SHA256SUMS.removePrefix("$ROOT/"), context).bufferedReader().useLines { + parseCommittedChecksums(it) + } + + internal fun parseCommittedChecksums(lines: Sequence): Map = + buildMap { + lines.forEachIndexed { index, line -> + if (line.isBlank() || line.startsWith("#")) { + return@forEachIndexed } + val match = requireNotNull(checksumLine.matchEntire(line)) { + "Malformed SHA256SUMS entry at line ${index + 1}" + } + val (hash, path) = match.destructured + require(path.isRelativePath()) { + "Unsafe SHA256SUMS path at line ${index + 1}: $path" + } + require(put(path, hash) == null) { + "Duplicate SHA256SUMS path at line ${index + 1}: $path" + } + } } private fun loadProperties(context: Context? = null): Properties = @@ -70,8 +96,9 @@ object PlayerTestFixtures { joinToString("") { byte -> "%02x".format(byte) } private fun String.isRelativePath(): Boolean = - isNotBlank() && !startsWith('/') && !contains('\n') && !contains('\r') && - split('/').none { it == ".." || it.isBlank() } + isNotBlank() && !startsWith('/') && !contains('\\') && + !contains('\n') && !contains('\r') && + split('/').none { it == "." || it == ".." || it.isBlank() } } enum class FixtureId( diff --git a/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt b/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt index 55739418..5f1245f2 100644 --- a/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt +++ b/player-test-fixtures/src/test/kotlin/com/kino/puber/playertestfixtures/PlayerTestFixturesTest.kt @@ -2,6 +2,7 @@ package com.kino.puber.playertestfixtures import java.security.MessageDigest import org.junit.Assert.assertEquals +import org.junit.Assert.fail import org.junit.Assert.assertTrue import org.junit.Test @@ -52,6 +53,20 @@ class PlayerTestFixturesTest { } } + @Test + fun checksumManifest_rejectsMalformedDuplicateAndUnsafeEntries() { + val hash = "0".repeat(64) + + assertChecksumManifestRejected("not-a-checksum progressive.mp4") + assertChecksumManifestRejected("$hash progressive.mp4") + assertChecksumManifestRejected("$hash ../progressive.mp4") + assertChecksumManifestRejected("$hash hls\\master.m3u8") + assertChecksumManifestRejected( + "$hash progressive.mp4", + "$hash progressive.mp4", + ) + } + @Test fun catalog_containsPlaybackTracksAndKnownSubtitleCue() { val catalog = PlayerTestFixtures.catalog @@ -113,4 +128,13 @@ class PlayerTestFixturesTest { ) } } + + private fun assertChecksumManifestRejected(vararg lines: String) { + try { + PlayerTestFixtures.parseCommittedChecksums(lines.asSequence()) + fail("Expected checksum manifest to be rejected: ${lines.joinToString()}") + } catch (_: IllegalArgumentException) { + // Expected: checksum manifests are parsed fail-closed. + } + } }