refactor: moved CompositeMediaRepository to the domain level + changes in connected classes

domain/src/main/java/hu/bbara/purefin/core/player/viewmodel/PlayerViewModel.kt

@@ -4,14 +4,13 @@ import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import hu.bbara.purefin.data.EpisodeSeriesLookup
-import hu.bbara.purefin.data.PlayableMediaRepository
 import hu.bbara.purefin.core.player.manager.PlayerManager
 import hu.bbara.purefin.core.player.manager.ProgressManager
 import hu.bbara.purefin.core.player.model.MediaContext
 import hu.bbara.purefin.core.player.model.PlayerUiState
 import hu.bbara.purefin.core.player.model.TrackOption
 import hu.bbara.purefin.core.player.preference.TrackPreferencesRepository
+import hu.bbara.purefin.data.PlayableMediaRepository
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -30,7 +29,6 @@ class PlayerViewModel @Inject constructor(
     private val playerManager: PlayerManager,
     private val playableMediaRepository: PlayableMediaRepository,
     private val trackPreferencesRepository: TrackPreferencesRepository,
-    private val episodeSeriesLookup: EpisodeSeriesLookup,
     private val progressManager: ProgressManager,
 ) : ViewModel() {
     companion object {
@@ -156,7 +154,10 @@ class PlayerViewModel @Inject constructor(
             if (result != null) {
                 val (mediaItem, resumePositionMs) = result
 
-                val preferenceKey = episodeSeriesLookup.preferenceKeyFor(uuid)
+
+                // TODO use CatalogReader for this instead of episodeSeriesLookup
+//                val preferenceKey = episodeSeriesLookup.preferenceKeyFor(uuid)
+                val preferenceKey = uuid.toString()
                 val preferences = trackPreferencesRepository.getMediaPreferences(preferenceKey).first()
                 val mediaSegments = playableMediaRepository.getMediaSegments(uuid)
 

domain/src/main/java/hu/bbara/purefin/data/CompositeMediaRepository.kt

@@ -0,0 +1,54 @@
+package hu.bbara.purefin.data
+
+import hu.bbara.purefin.data.catalog.InMemoryMediaRepository
+import hu.bbara.purefin.data.catalog.OfflineMediaRepository
+import hu.bbara.purefin.model.Episode
+import hu.bbara.purefin.model.Movie
+import hu.bbara.purefin.model.Series
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.stateIn
+import java.util.UUID
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@Singleton
+class CompositeMediaRepository @Inject constructor(
+    private val offlineRepository: OfflineMediaRepository,
+    private val onlineRepository: InMemoryMediaRepository,
+) : MediaCatalogReader, MediaProgressWriter {
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    // TODO move this into the domain layer and there you can use NetworkMonitor. Data should be free of android stuff.
+    private val activeRepository: Flow<MediaCatalogReader> = flowOf(onlineRepository)
+
+    override val movies: StateFlow<Map<UUID, Movie>> = activeRepository
+        .flatMapLatest { it.movies }
+        .stateIn(scope, SharingStarted.Companion.Eagerly, emptyMap())
+
+    override val series: StateFlow<Map<UUID, Series>> = activeRepository
+        .flatMapLatest { it.series }
+        .stateIn(scope, SharingStarted.Companion.Eagerly, emptyMap())
+
+    override val episodes: StateFlow<Map<UUID, Episode>> = activeRepository
+        .flatMapLatest { it.episodes }
+        .stateIn(scope, SharingStarted.Companion.Eagerly, emptyMap())
+
+    override fun observeSeriesWithContent(seriesId: UUID): Flow<Series?> {
+        return activeRepository.flatMapLatest { it.observeSeriesWithContent(seriesId) }
+    }
+
+    override suspend fun updateWatchProgress(mediaId: UUID, positionMs: Long, durationMs: Long) {
+        val repository = onlineRepository
+        repository.updateWatchProgress(mediaId, positionMs, durationMs)
+    }
+}

domain/src/main/java/hu/bbara/purefin/module/RepositoryModule.kt

@@ -0,0 +1,26 @@
+package hu.bbara.purefin.module
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import hu.bbara.purefin.data.CompositeMediaRepository
+import hu.bbara.purefin.data.HomeRepository
+import hu.bbara.purefin.data.MediaCatalogReader
+import hu.bbara.purefin.data.MediaProgressWriter
+import hu.bbara.purefin.data.catalog.InMemoryAppContentRepository
+
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class RepositoryModule {
+
+    @Binds
+    abstract fun bindHomeRepository(impl: InMemoryAppContentRepository): HomeRepository
+
+    @Binds
+    abstract fun bindMediaCatalogReader(impl: CompositeMediaRepository): MediaCatalogReader
+
+    @Binds
+    abstract fun bindMediaProgressWrite(impl: CompositeMediaRepository): MediaProgressWriter
+}