StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktindex 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.AppSettingsPlatformHostimport com.streamvault.domain.model.Resultimport com.streamvault.feature.settings.api.SettingsPlatformHostimport 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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+ }+}