Skip to content

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

feat(catalog): adapt app platform services

David Nashash70023eeaf6c9
diff --git a/app/src/main/java/com/streamvault/app/MainActivity.kt b/app/src/main/java/com/streamvault/app/MainActivity.kt
index 524d576c..6981be1e 100644
--- a/app/src/main/java/com/streamvault/app/MainActivity.kt
+++ b/app/src/main/java/com/streamvault/app/MainActivity.kt
@@ -77,9 +77,10 @@ import com.streamvault.app.settings.AppSettingsPlatformHost
import com.streamvault.domain.model.Result
import com.streamvault.feature.settings.api.SettingsPlatformHost
import com.streamvault.feature.settings.api.SettingsRecordingPlaybackRequest
+import com.streamvault.feature.catalog.api.CatalogPlatformHost
@AndroidEntryPoint
-class MainActivity : ComponentActivity() {
+class MainActivity : ComponentActivity(), CatalogPlatformHost {
companion object {
const val EXTRA_PLAYER_REQUEST = "com.streamvault.app.extra.PLAYER_REQUEST"
@@ -348,7 +349,7 @@ class MainActivity : ComponentActivity() {
}
}
- fun openCastRouteChooser() {
+ override fun openCastRouteChooser() {
startActivity(Intent(this, CastRouteChooserActivity::class.java))
}
diff --git a/app/src/main/java/com/streamvault/app/catalog/AppCatalogCastPort.kt b/app/src/main/java/com/streamvault/app/catalog/AppCatalogCastPort.kt
new file mode 100644
index 00000000..fd5019c5
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/catalog/AppCatalogCastPort.kt
@@ -0,0 +1,105 @@
+package com.streamvault.app.catalog
+
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.feature.catalog.api.CatalogCastPlaybackEvent
+import com.streamvault.feature.catalog.api.CatalogCastPort
+import com.streamvault.feature.catalog.api.CatalogCastRequest
+import com.streamvault.feature.catalog.api.CatalogCastStartResult
+import com.streamvault.feature.catalog.api.CatalogMessage
+import com.streamvault.feature.playback.api.CastMediaRequest
+import com.streamvault.feature.playback.cast.CastMediaRequestBuildResult
+import com.streamvault.feature.playback.cast.CastMediaRequestFactory
+import com.streamvault.feature.playback.cast.CastPlaybackCoordinator
+import com.streamvault.feature.playback.cast.CastPlaybackEvent
+import com.streamvault.feature.playback.cast.CastStartResult
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+import javax.inject.Singleton
+
+internal interface AppCatalogCastOperations {
+ val playbackEvents: Flow<CastPlaybackEvent>
+
+ fun buildRequest(
+ streamInfo: StreamInfo,
+ title: String,
+ subtitle: String?,
+ artworkUrl: String?,
+ startPositionMs: Long,
+ ): CastMediaRequestBuildResult
+
+ suspend fun startCasting(request: CastMediaRequest): CastStartResult
+}
+
+@Singleton
+class AppCatalogCastPort internal constructor(
+ private val operations: AppCatalogCastOperations,
+) : CatalogCastPort {
+ @Inject
+ constructor(
+ requestFactory: CastMediaRequestFactory,
+ playbackCoordinator: CastPlaybackCoordinator,
+ ) : this(
+ object : AppCatalogCastOperations {
+ override val playbackEvents: Flow<CastPlaybackEvent> = playbackCoordinator.playbackEvents
+
+ override fun buildRequest(
+ streamInfo: StreamInfo,
+ title: String,
+ subtitle: String?,
+ artworkUrl: String?,
+ startPositionMs: Long,
+ ): CastMediaRequestBuildResult = requestFactory.buildFromStreamInfo(
+ streamInfo = streamInfo,
+ title = title,
+ subtitle = subtitle,
+ artworkUrl = artworkUrl,
+ isLive = false,
+ startPositionMs = startPositionMs,
+ )
+
+ override suspend fun startCasting(request: CastMediaRequest): CastStartResult =
+ playbackCoordinator.startCasting(request)
+ }
+ )
+
+ override val playbackEvents: Flow<CatalogCastPlaybackEvent> =
+ operations.playbackEvents.map(::mapPlaybackEvent)
+
+ override suspend fun startCasting(request: CatalogCastRequest): CatalogCastStartResult {
+ return when (val buildResult = operations.buildRequest(
+ streamInfo = request.streamInfo,
+ title = request.title,
+ subtitle = request.subtitle,
+ artworkUrl = request.artworkUrl,
+ startPositionMs = request.startPositionMs,
+ )) {
+ is CastMediaRequestBuildResult.Unsupported ->
+ CatalogCastStartResult.Unsupported(CatalogMessage.CastUnsupported)
+
+ is CastMediaRequestBuildResult.Success ->
+ mapStartResult(operations.startCasting(buildResult.request))
+ }
+ }
+
+ private fun mapStartResult(result: CastStartResult): CatalogCastStartResult = when (result) {
+ CastStartResult.STARTED -> CatalogCastStartResult.Started
+ CastStartResult.ROUTE_SELECTION_REQUIRED -> CatalogCastStartResult.RouteSelectionRequired
+ CastStartResult.UNAVAILABLE -> CatalogCastStartResult.Unavailable
+ CastStartResult.UNSUPPORTED ->
+ CatalogCastStartResult.Unsupported(CatalogMessage.CastUnsupported)
+ }
+
+ private fun mapPlaybackEvent(event: CastPlaybackEvent): CatalogCastPlaybackEvent = when (event) {
+ CastPlaybackEvent.RouteSelectionCancelled ->
+ CatalogCastPlaybackEvent.RouteSelectionCancelled
+ is CastPlaybackEvent.MediaLoadSucceeded ->
+ CatalogCastPlaybackEvent.Finished(true, CatalogMessage.CastStarted)
+ is CastPlaybackEvent.MediaLoadFailed ->
+ CatalogCastPlaybackEvent.Finished(false, CatalogMessage.CastLoadFailed)
+ is CastPlaybackEvent.SessionStartFailed ->
+ CatalogCastPlaybackEvent.Finished(false, CatalogMessage.CastSessionFailed)
+ is CastPlaybackEvent.ReceiverUnavailable ->
+ CatalogCastPlaybackEvent.Finished(false, CatalogMessage.CastUnavailable)
+ }
+}
diff --git a/app/src/main/java/com/streamvault/app/catalog/AppCatalogDownloadStarter.kt b/app/src/main/java/com/streamvault/app/catalog/AppCatalogDownloadStarter.kt
new file mode 100644
index 00000000..ccf7a370
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/catalog/AppCatalogDownloadStarter.kt
@@ -0,0 +1,22 @@
+package com.streamvault.app.catalog
+
+import com.streamvault.app.service.DownloadForegroundService
+import com.streamvault.feature.catalog.api.CatalogDownloadStarter
+import android.content.Context
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AppCatalogDownloadStarter internal constructor(
+ private val start: (String) -> Unit,
+) : CatalogDownloadStarter {
+ @Inject
+ constructor(@ApplicationContext context: Context) : this(
+ { downloadId -> DownloadForegroundService.startDownload(context, downloadId) }
+ )
+
+ override fun startDownload(downloadId: String) {
+ start(downloadId)
+ }
+}
diff --git a/app/src/main/java/com/streamvault/app/catalog/AppCatalogStreamPreparer.kt b/app/src/main/java/com/streamvault/app/catalog/AppCatalogStreamPreparer.kt
new file mode 100644
index 00000000..08bbd652
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/catalog/AppCatalogStreamPreparer.kt
@@ -0,0 +1,21 @@
+package com.streamvault.app.catalog
+
+import com.streamvault.app.plugins.StreamVaultPluginManager
+import com.streamvault.domain.model.Result
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.feature.catalog.api.CatalogStreamPreparer
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AppCatalogStreamPreparer internal constructor(
+ private val preparePlayback: suspend (StreamInfo) -> Result<StreamInfo>,
+) : CatalogStreamPreparer {
+ @Inject
+ constructor(pluginManager: StreamVaultPluginManager) : this(
+ pluginManager::preparePlaybackStreamInfo
+ )
+
+ override suspend fun prepare(streamInfo: StreamInfo): Result<StreamInfo> =
+ preparePlayback(streamInfo)
+}
diff --git a/app/src/main/java/com/streamvault/app/catalog/AppCatalogUpdatePort.kt b/app/src/main/java/com/streamvault/app/catalog/AppCatalogUpdatePort.kt
new file mode 100644
index 00000000..fb66e466
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/catalog/AppCatalogUpdatePort.kt
@@ -0,0 +1,96 @@
+package com.streamvault.app.catalog
+
+import com.streamvault.app.update.AppUpdateActionState
+import com.streamvault.app.update.AppUpdateInstaller
+import com.streamvault.app.update.isRemoteVersionNewer
+import com.streamvault.app.update.latestAppUpdateAction
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.model.Result
+import com.streamvault.feature.catalog.api.CatalogAppUpdatePort
+import com.streamvault.feature.catalog.api.CatalogUpdateAction
+import com.streamvault.feature.catalog.api.CatalogUpdateNotice
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AppCatalogUpdatePort internal constructor(
+ override val notice: Flow<CatalogUpdateNotice?>,
+ private val install: suspend (String?) -> Result<Unit>,
+) : CatalogAppUpdatePort {
+ @Inject
+ constructor(
+ preferencesRepository: PreferencesRepository,
+ updateInstaller: AppUpdateInstaller,
+ ) : this(
+ notice = observeCatalogUpdateNotice(preferencesRepository, updateInstaller),
+ install = updateInstaller::installDownloadedUpdate,
+ )
+
+ override suspend fun installDownloadedUpdate(expectedSha256: String?): Result<Unit> =
+ install(expectedSha256)
+
+ companion object {
+ internal fun mapAction(action: AppUpdateActionState): CatalogUpdateAction = when (action) {
+ AppUpdateActionState.None -> CatalogUpdateAction.None
+ AppUpdateActionState.DownloadLatest -> CatalogUpdateAction.DownloadLatest
+ AppUpdateActionState.Downloading -> CatalogUpdateAction.Downloading
+ AppUpdateActionState.InstallLatest -> CatalogUpdateAction.InstallLatest
+ AppUpdateActionState.InstallPermissionRequired ->
+ CatalogUpdateAction.InstallPermissionRequired
+ }
+ }
+}
+
+private fun observeCatalogUpdateNotice(
+ preferencesRepository: PreferencesRepository,
+ updateInstaller: AppUpdateInstaller,
+): Flow<CatalogUpdateNotice?> {
+ val cachedRelease = combine(
+ preferencesRepository.cachedAppUpdateVersionName,
+ preferencesRepository.cachedAppUpdateVersionCode,
+ preferencesRepository.cachedAppUpdatePublishedAt,
+ preferencesRepository.cachedAppUpdateDownloadUrl,
+ preferencesRepository.cachedAppUpdateDownloadSha256,
+ ) { latestVersionName, latestVersionCode, publishedAt, downloadUrl, downloadSha256 ->
+ CachedCatalogUpdateRelease(
+ latestVersionName = latestVersionName,
+ latestVersionCode = latestVersionCode,
+ publishedAt = publishedAt,
+ downloadUrl = downloadUrl,
+ downloadSha256 = downloadSha256,
+ )
+ }
+
+ return cachedRelease.combine(updateInstaller.downloadState) { release, downloadState ->
+ val latestVersionName = release.latestVersionName ?: return@combine null
+ val updateAvailable = isRemoteVersionNewer(
+ release.latestVersionCode,
+ latestVersionName,
+ release.publishedAt,
+ )
+ if (!updateAvailable) return@combine null
+
+ CatalogUpdateNotice(
+ latestVersionName = latestVersionName,
+ downloadSha256 = release.downloadSha256,
+ action = AppCatalogUpdatePort.mapAction(
+ latestAppUpdateAction(
+ latestVersionName = latestVersionName,
+ downloadUrl = release.downloadUrl,
+ isUpdateAvailable = updateAvailable,
+ downloadState = downloadState,
+ )
+ ),
+ )
+ }
+}
+
+private data class CachedCatalogUpdateRelease(
+ val latestVersionName: String?,
+ val latestVersionCode: Int?,
+ val publishedAt: String?,
+ val downloadUrl: String?,
+ val downloadSha256: String?,
+)
diff --git a/app/src/main/java/com/streamvault/app/di/AppCatalogModule.kt b/app/src/main/java/com/streamvault/app/di/AppCatalogModule.kt
new file mode 100644
index 00000000..6011fc5a
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/di/AppCatalogModule.kt
@@ -0,0 +1,35 @@
+package com.streamvault.app.di
+
+import com.streamvault.app.catalog.AppCatalogCastPort
+import com.streamvault.app.catalog.AppCatalogDownloadStarter
+import com.streamvault.app.catalog.AppCatalogStreamPreparer
+import com.streamvault.app.catalog.AppCatalogUpdatePort
+import com.streamvault.feature.catalog.api.CatalogAppUpdatePort
+import com.streamvault.feature.catalog.api.CatalogCastPort
+import com.streamvault.feature.catalog.api.CatalogDownloadStarter
+import com.streamvault.feature.catalog.api.CatalogStreamPreparer
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class AppCatalogModule {
+ @Binds
+ @Singleton
+ abstract fun bindStreamPreparer(impl: AppCatalogStreamPreparer): CatalogStreamPreparer
+
+ @Binds
+ @Singleton
+ abstract fun bindDownloadStarter(impl: AppCatalogDownloadStarter): CatalogDownloadStarter
+
+ @Binds
+ @Singleton
+ abstract fun bindCastPort(impl: AppCatalogCastPort): CatalogCastPort
+
+ @Binds
+ @Singleton
+ abstract fun bindUpdatePort(impl: AppCatalogUpdatePort): CatalogAppUpdatePort
+}
diff --git a/app/src/test/java/com/streamvault/app/catalog/AppCatalogAdaptersTest.kt b/app/src/test/java/com/streamvault/app/catalog/AppCatalogAdaptersTest.kt
new file mode 100644
index 00000000..7a71d100
--- /dev/null
+++ b/app/src/test/java/com/streamvault/app/catalog/AppCatalogAdaptersTest.kt
@@ -0,0 +1,173 @@
+package com.streamvault.app.catalog
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.app.update.AppUpdateActionState
+import com.streamvault.domain.model.Result
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.feature.catalog.api.CatalogCastPlaybackEvent
+import com.streamvault.feature.catalog.api.CatalogCastRequest
+import com.streamvault.feature.catalog.api.CatalogCastStartResult
+import com.streamvault.feature.catalog.api.CatalogMessage
+import com.streamvault.feature.catalog.api.CatalogUpdateAction
+import com.streamvault.feature.playback.api.CastMediaRequest
+import com.streamvault.feature.playback.cast.CastMediaRequestBuildResult
+import com.streamvault.feature.playback.cast.CastPlaybackEvent
+import com.streamvault.feature.playback.cast.CastStartResult
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.runCurrent
+import org.junit.Test
+
+class AppCatalogAdaptersTest {
+ @Test
+ fun `stream preparer delegates without rewriting result`() = runTest {
+ val input = StreamInfo(url = "https://example.test/input.m3u8")
+ val output = StreamInfo(url = "https://example.test/prepared.m3u8")
+ val calls = mutableListOf<StreamInfo>()
+ val adapter = AppCatalogStreamPreparer { streamInfo ->
+ calls += streamInfo
+ Result.Success(output)
+ }
+
+ assertThat(adapter.prepare(input)).isEqualTo(Result.Success(output))
+ assertThat(calls).containsExactly(input)
+ }
+
+ @Test
+ fun `download starter forwards string id to injected service launcher`() {
+ val calls = mutableListOf<String>()
+ val adapter = AppCatalogDownloadStarter { downloadId ->
+ calls += downloadId
+ }
+
+ adapter.startDownload("download-42")
+
+ assertThat(calls).containsExactly("download-42")
+ }
+
+ @Test
+ fun `cast adapter preserves request fields and maps start results`() = runTest {
+ val input = CatalogCastRequest(
+ streamInfo = StreamInfo(url = "https://example.test/movie.m3u8"),
+ title = "Movie",
+ subtitle = "2026",
+ artworkUrl = "https://example.test/poster.jpg",
+ startPositionMs = 42_000L,
+ )
+ val operations = FakeCastOperations(CastStartResult.STARTED)
+ val adapter = AppCatalogCastPort(operations)
+
+ assertThat(adapter.startCasting(input)).isEqualTo(CatalogCastStartResult.Started)
+ assertThat(operations.request).isEqualTo(
+ CastMediaRequest(
+ url = input.streamInfo.url,
+ title = input.title,
+ subtitle = input.subtitle,
+ artworkUrl = input.artworkUrl,
+ startPositionMs = input.startPositionMs,
+ )
+ )
+ }
+
+ @Test
+ fun `cast adapter maps every start result`() = runTest {
+ val input = CatalogCastRequest(StreamInfo("https://example.test/movie.m3u8"), "Movie", null, null, 0L)
+ val expected = listOf(
+ CastStartResult.STARTED to CatalogCastStartResult.Started,
+ CastStartResult.ROUTE_SELECTION_REQUIRED to CatalogCastStartResult.RouteSelectionRequired,
+ CastStartResult.UNAVAILABLE to CatalogCastStartResult.Unavailable,
+ CastStartResult.UNSUPPORTED to CatalogCastStartResult.Unsupported(CatalogMessage.CastUnsupported),
+ )
+
+ expected.forEach { (playbackResult, catalogResult) ->
+ assertThat(AppCatalogCastPort(FakeCastOperations(playbackResult)).startCasting(input))
+ .isEqualTo(catalogResult)
+ }
+ }
+
+ @OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+ @Test
+ fun `cast adapter maps ordered lifecycle events without playback types`() = runTest {
+ val playbackEvents = MutableSharedFlow<CastPlaybackEvent>(extraBufferCapacity = 8)
+ val adapter = AppCatalogCastPort(FakeCastOperations(CastStartResult.STARTED, playbackEvents))
+ val collected = mutableListOf<CatalogCastPlaybackEvent>()
+ val job = backgroundScope.launch {
+ adapter.playbackEvents.collect { collected += it }
+ }
+ runCurrent()
+
+ playbackEvents.emit(CastPlaybackEvent.RouteSelectionCancelled)
+ playbackEvents.emit(CastPlaybackEvent.MediaLoadSucceeded("Movie"))
+ playbackEvents.emit(CastPlaybackEvent.MediaLoadFailed("Movie"))
+ playbackEvents.emit(CastPlaybackEvent.SessionStartFailed(7))
+ playbackEvents.emit(CastPlaybackEvent.ReceiverUnavailable("Movie"))
+ runCurrent()
+
+ assertThat(collected).containsExactly(
+ CatalogCastPlaybackEvent.RouteSelectionCancelled,
+ CatalogCastPlaybackEvent.Finished(true, CatalogMessage.CastStarted),
+ CatalogCastPlaybackEvent.Finished(false, CatalogMessage.CastLoadFailed),
+ CatalogCastPlaybackEvent.Finished(false, CatalogMessage.CastSessionFailed),
+ CatalogCastPlaybackEvent.Finished(false, CatalogMessage.CastUnavailable),
+ ).inOrder()
+ job.cancel()
+ }
+
+ @Test
+ fun `update action mapping preserves all existing states`() {
+ assertThat(AppCatalogUpdatePort.mapAction(AppUpdateActionState.None))
+ .isEqualTo(CatalogUpdateAction.None)
+ assertThat(AppCatalogUpdatePort.mapAction(AppUpdateActionState.DownloadLatest))
+ .isEqualTo(CatalogUpdateAction.DownloadLatest)
+ assertThat(AppCatalogUpdatePort.mapAction(AppUpdateActionState.Downloading))
+ .isEqualTo(CatalogUpdateAction.Downloading)
+ assertThat(AppCatalogUpdatePort.mapAction(AppUpdateActionState.InstallLatest))
+ .isEqualTo(CatalogUpdateAction.InstallLatest)
+ assertThat(AppCatalogUpdatePort.mapAction(AppUpdateActionState.InstallPermissionRequired))
+ .isEqualTo(CatalogUpdateAction.InstallPermissionRequired)
+ }
+
+ @Test
+ fun `update adapter forwards install sha unchanged`() = runTest {
+ var receivedSha: String? = null
+ val adapter = AppCatalogUpdatePort(
+ notice = MutableStateFlow(null),
+ install = { sha ->
+ receivedSha = sha
+ Result.Success(Unit)
+ },
+ )
+
+ assertThat(adapter.installDownloadedUpdate("sha-256")).isEqualTo(Result.Success(Unit))
+ assertThat(receivedSha).isEqualTo("sha-256")
+ }
+
+ private class FakeCastOperations(
+ private val result: CastStartResult,
+ override val playbackEvents: Flow<CastPlaybackEvent> = MutableSharedFlow(extraBufferCapacity = 8),
+ ) : AppCatalogCastOperations {
+ var request: CastMediaRequest? = null
+
+ override fun buildRequest(
+ streamInfo: StreamInfo,
+ title: String,
+ subtitle: String?,
+ artworkUrl: String?,
+ startPositionMs: Long,
+ ): CastMediaRequestBuildResult {
+ request = CastMediaRequest(
+ url = streamInfo.url,
+ title = title,
+ subtitle = subtitle,
+ artworkUrl = artworkUrl,
+ startPositionMs = startPositionMs,
+ )
+ return CastMediaRequestBuildResult.Success(request!!)
+ }
+
+ override suspend fun startCasting(request: CastMediaRequest): CastStartResult = result
+ }
+}