refactor: modularize app into multi-module architecture

2026-03-31 17:10:08 +02:00 · 2026-02-21 00:15:51 +01:00
parent 8601ef0236
commit 7333781f83
123 changed files with 668 additions and 404 deletions
--- a/feature/download/build.gradle.kts
+++ b/feature/download/build.gradle.kts
@@ -0,0 +1,39 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.hilt)
+    alias(libs.plugins.ksp)
+}
+
+android {
+    namespace = "hu.bbara.purefin.feature.download"
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 29
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
+    }
+}
+
+dependencies {
+    implementation(project(":core:model"))
+    implementation(project(":core:data"))
+    implementation(libs.hilt)
+    ksp(libs.hilt.compiler)
+    implementation(libs.medi3.exoplayer)
+    implementation(libs.media3.datasource.okhttp)
+    implementation(libs.okhttp)
+    implementation(libs.jellyfin.core)
+}
--- a/feature/download/src/main/java/hu/bbara/purefin/feature/download/DownloadModule.kt
+++ b/feature/download/src/main/java/hu/bbara/purefin/feature/download/DownloadModule.kt
@@ -0,0 +1,75 @@
+package hu.bbara.purefin.feature.download
+
+import android.content.Context
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.database.StandaloneDatabaseProvider
+import androidx.media3.datasource.cache.CacheDataSource
+import androidx.media3.datasource.cache.NoOpCacheEvictor
+import androidx.media3.datasource.cache.SimpleCache
+import androidx.media3.datasource.okhttp.OkHttpDataSource
+import androidx.media3.exoplayer.offline.DownloadManager
+import androidx.media3.exoplayer.offline.DownloadNotificationHelper
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import okhttp3.OkHttpClient
+import java.io.File
+import java.util.concurrent.Executors
+import javax.inject.Singleton
+
+@OptIn(UnstableApi::class)
+@Module
+@InstallIn(SingletonComponent::class)
+object DownloadModule {
+
+    private const val DOWNLOAD_CHANNEL_ID = "purefin_downloads"
+
+    @Provides
+    @Singleton
+    fun provideDownloadCache(@ApplicationContext context: Context): SimpleCache {
+        val downloadDir = File(context.getExternalFilesDir(null), "downloads")
+        return SimpleCache(downloadDir, NoOpCacheEvictor(), StandaloneDatabaseProvider(context))
+    }
+
+    @Provides
+    @Singleton
+    fun provideOkHttpDataSourceFactory(okHttpClient: OkHttpClient): OkHttpDataSource.Factory {
+        return OkHttpDataSource.Factory(okHttpClient)
+    }
+
+    @Provides
+    @Singleton
+    fun provideDownloadNotificationHelper(@ApplicationContext context: Context): DownloadNotificationHelper {
+        return DownloadNotificationHelper(context, DOWNLOAD_CHANNEL_ID)
+    }
+
+    @Provides
+    @Singleton
+    fun provideDownloadManager(
+        @ApplicationContext context: Context,
+        cache: SimpleCache,
+        okHttpDataSourceFactory: OkHttpDataSource.Factory
+    ): DownloadManager {
+        return DownloadManager(
+            context,
+            StandaloneDatabaseProvider(context),
+            cache,
+            okHttpDataSourceFactory,
+            Executors.newFixedThreadPool(2)
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideCacheDataSourceFactory(
+        cache: SimpleCache,
+        okHttpDataSourceFactory: OkHttpDataSource.Factory
+    ): CacheDataSource.Factory {
+        return CacheDataSource.Factory()
+            .setCache(cache)
+            .setUpstreamDataSourceFactory(okHttpDataSourceFactory)
+    }
+}
--- a/feature/download/src/main/java/hu/bbara/purefin/feature/download/DownloadState.kt
+++ b/feature/download/src/main/java/hu/bbara/purefin/feature/download/DownloadState.kt
@@ -0,0 +1,8 @@
+package hu.bbara.purefin.feature.download
+
+sealed class DownloadState {
+    data object NotDownloaded : DownloadState()
+    data class Downloading(val progressPercent: Float) : DownloadState()
+    data object Downloaded : DownloadState()
+    data object Failed : DownloadState()
+}
--- a/feature/download/src/main/java/hu/bbara/purefin/feature/download/MediaDownloadManager.kt
+++ b/feature/download/src/main/java/hu/bbara/purefin/feature/download/MediaDownloadManager.kt
@@ -0,0 +1,172 @@
+package hu.bbara.purefin.feature.download
+
+import android.content.Context
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.core.net.toUri
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.offline.Download
+import androidx.media3.exoplayer.offline.DownloadManager
+import androidx.media3.exoplayer.offline.DownloadRequest
+import dagger.hilt.android.qualifiers.ApplicationContext
+import hu.bbara.purefin.core.data.client.JellyfinApiClient
+import hu.bbara.purefin.core.data.image.JellyfinImageHelper
+import hu.bbara.purefin.core.data.local.room.OfflineDatabase
+import hu.bbara.purefin.core.data.local.room.OfflineRoomMediaLocalDataSource
+import hu.bbara.purefin.core.data.local.room.dao.MovieDao
+import hu.bbara.purefin.core.data.session.UserSessionRepository
+import hu.bbara.purefin.core.model.Movie
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import org.jellyfin.sdk.model.api.ImageType
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@OptIn(UnstableApi::class)
+@Singleton
+class MediaDownloadManager @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val downloadManager: DownloadManager,
+    private val jellyfinApiClient: JellyfinApiClient,
+    @OfflineDatabase private val offlineDataSource: OfflineRoomMediaLocalDataSource,
+    @OfflineDatabase private val movieDao: MovieDao,
+    private val userSessionRepository: UserSessionRepository
+) {
+
+    private val stateFlows = ConcurrentHashMap<String, MutableStateFlow<DownloadState>>()
+
+    init {
+        downloadManager.resumeDownloads()
+
+        downloadManager.addListener(object : DownloadManager.Listener {
+            override fun onDownloadChanged(
+                manager: DownloadManager,
+                download: Download,
+                finalException: Exception?
+            ) {
+                val contentId = download.request.id
+                val state = download.toDownloadState()
+                Log.d(TAG, "Download changed: $contentId -> $state (${download.percentDownloaded}%)")
+                if (finalException != null) {
+                    Log.e(TAG, "Download exception for $contentId", finalException)
+                }
+                getOrCreateStateFlow(contentId).value = state
+            }
+
+            override fun onDownloadRemoved(manager: DownloadManager, download: Download) {
+                val contentId = download.request.id
+                Log.d(TAG, "Download removed: $contentId")
+                getOrCreateStateFlow(contentId).value = DownloadState.NotDownloaded
+            }
+        })
+    }
+
+    fun observeDownloadState(contentId: String): StateFlow<DownloadState> {
+        val flow = getOrCreateStateFlow(contentId)
+        // Initialize from current download index
+        val download = downloadManager.downloadIndex.getDownload(contentId)
+        flow.value = download?.toDownloadState() ?: DownloadState.NotDownloaded
+        return flow
+    }
+
+    fun isDownloaded(contentId: String): Boolean {
+        return downloadManager.downloadIndex.getDownload(contentId)?.state == Download.STATE_COMPLETED
+    }
+
+    suspend fun downloadMovie(movieId: UUID) {
+        withContext(Dispatchers.IO) {
+            try {
+                val sources = jellyfinApiClient.getMediaSources(movieId)
+                val source = sources.firstOrNull() ?: run {
+                    Log.e(TAG, "No media sources for $movieId")
+                    return@withContext
+                }
+
+                val url = jellyfinApiClient.getMediaPlaybackUrl(movieId, source) ?: run {
+                    Log.e(TAG, "No playback URL for $movieId")
+                    return@withContext
+                }
+
+                val itemInfo = jellyfinApiClient.getItemInfo(movieId) ?: run {
+                    Log.e(TAG, "No item info for $movieId")
+                    return@withContext
+                }
+
+                val serverUrl = userSessionRepository.serverUrl.first().trim()
+                val movie = Movie(
+                    id = itemInfo.id,
+                    libraryId = itemInfo.parentId ?: UUID.randomUUID(),
+                    title = itemInfo.name ?: "Unknown title",
+                    progress = itemInfo.userData?.playedPercentage,
+                    watched = itemInfo.userData?.played ?: false,
+                    year = itemInfo.productionYear?.toString()
+                        ?: itemInfo.premiereDate?.year?.toString().orEmpty(),
+                    rating = itemInfo.officialRating ?: "NR",
+                    runtime = formatRuntime(itemInfo.runTimeTicks),
+                    synopsis = itemInfo.overview ?: "No synopsis available",
+                    format = itemInfo.container?.uppercase() ?: "VIDEO",
+                    heroImageUrl = JellyfinImageHelper.toImageUrl(
+                        url = serverUrl,
+                        itemId = itemInfo.id,
+                        type = ImageType.PRIMARY
+                    ),
+                    subtitles = "ENG",
+                    audioTrack = "ENG",
+                    cast = emptyList()
+                )
+
+                offlineDataSource.saveMovies(listOf(movie))
+
+                Log.d(TAG, "Starting download for '${movie.title}' from: $url")
+                val request = DownloadRequest.Builder(movieId.toString(), url.toUri()).build()
+                PurefinDownloadService.sendAddDownload(context, request)
+                Log.d(TAG, "Download request sent for $movieId")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to start download for $movieId", e)
+                getOrCreateStateFlow(movieId.toString()).value = DownloadState.Failed
+            }
+        }
+    }
+
+    suspend fun cancelDownload(movieId: UUID) {
+        withContext(Dispatchers.IO) {
+            PurefinDownloadService.sendRemoveDownload(context, movieId.toString())
+            try {
+                movieDao.deleteById(movieId)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to remove movie from offline DB", e)
+            }
+        }
+    }
+
+    private fun getOrCreateStateFlow(contentId: String): MutableStateFlow<DownloadState> {
+        return stateFlows.getOrPut(contentId) { MutableStateFlow(DownloadState.NotDownloaded) }
+    }
+
+    private fun Download.toDownloadState(): DownloadState = when (state) {
+        Download.STATE_COMPLETED -> DownloadState.Downloaded
+        Download.STATE_DOWNLOADING -> DownloadState.Downloading(percentDownloaded)
+        Download.STATE_QUEUED, Download.STATE_RESTARTING -> DownloadState.Downloading(0f)
+        Download.STATE_FAILED -> DownloadState.Failed
+        Download.STATE_REMOVING -> DownloadState.NotDownloaded
+        Download.STATE_STOPPED -> DownloadState.NotDownloaded
+        else -> DownloadState.NotDownloaded
+    }
+
+    private fun formatRuntime(ticks: Long?): String {
+        if (ticks == null || ticks <= 0) return "—"
+        val totalSeconds = ticks / 10_000_000
+        val hours = java.util.concurrent.TimeUnit.SECONDS.toHours(totalSeconds)
+        val minutes = java.util.concurrent.TimeUnit.SECONDS.toMinutes(totalSeconds) % 60
+        return if (hours > 0) "${hours}h ${minutes}m" else "${minutes}m"
+    }
+
+    companion object {
+        private const val TAG = "MediaDownloadManager"
+    }
+}
--- a/feature/download/src/main/java/hu/bbara/purefin/feature/download/PurefinDownloadService.kt
+++ b/feature/download/src/main/java/hu/bbara/purefin/feature/download/PurefinDownloadService.kt
@@ -0,0 +1,137 @@
+package hu.bbara.purefin.feature.download
+
+import android.app.Notification
+import android.content.Context
+import androidx.annotation.OptIn
+import androidx.core.app.NotificationCompat
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.offline.Download
+import androidx.media3.exoplayer.offline.DownloadManager
+import androidx.media3.exoplayer.offline.DownloadNotificationHelper
+import androidx.media3.exoplayer.offline.DownloadRequest
+import androidx.media3.exoplayer.offline.DownloadService
+import androidx.media3.exoplayer.scheduler.Scheduler
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
+
+@OptIn(UnstableApi::class)
+class PurefinDownloadService : DownloadService(
+    FOREGROUND_NOTIFICATION_ID,
+    DEFAULT_FOREGROUND_NOTIFICATION_UPDATE_INTERVAL,
+    DOWNLOAD_CHANNEL_ID,
+    R.string.download_channel_name,
+    R.string.download_channel_description
+) {
+
+    @EntryPoint
+    @InstallIn(SingletonComponent::class)
+    interface DownloadServiceEntryPoint {
+        fun downloadManager(): DownloadManager
+        fun downloadNotificationHelper(): DownloadNotificationHelper
+    }
+
+    private val entryPoint: DownloadServiceEntryPoint by lazy {
+        EntryPointAccessors.fromApplication(applicationContext, DownloadServiceEntryPoint::class.java)
+    }
+
+    private var lastBytesDownloaded: Long = 0L
+    private var lastUpdateTimeMs: Long = 0L
+
+    override fun getDownloadManager(): DownloadManager = entryPoint.downloadManager()
+
+    override fun getForegroundNotification(
+        downloads: MutableList<Download>,
+        notMetRequirements: Int
+    ): Notification {
+        val activeDownloads = downloads.filter { it.state == Download.STATE_DOWNLOADING }
+
+        if (activeDownloads.isEmpty()) {
+            return entryPoint.downloadNotificationHelper().buildProgressNotification(
+                this,
+                R.drawable.ic_launcher_foreground,
+                null,
+                null,
+                downloads,
+                notMetRequirements
+            )
+        }
+
+        val totalBytes = activeDownloads.sumOf { it.bytesDownloaded }
+        val now = System.currentTimeMillis()
+
+        val speedText = if (lastUpdateTimeMs > 0L) {
+            val elapsed = (now - lastUpdateTimeMs).coerceAtLeast(1)
+            val bytesPerSec = (totalBytes - lastBytesDownloaded) * 1000L / elapsed
+            formatSpeed(bytesPerSec)
+        } else {
+            ""
+        }
+
+        lastBytesDownloaded = totalBytes
+        lastUpdateTimeMs = now
+
+        val percent = if (activeDownloads.size == 1) {
+            activeDownloads[0].percentDownloaded
+        } else {
+            activeDownloads.map { it.percentDownloaded }.average().toFloat()
+        }
+
+        val title = if (activeDownloads.size == 1) {
+            "Downloading"
+        } else {
+            "Downloading ${activeDownloads.size} files"
+        }
+
+        val contentText = buildString {
+            append("${percent.toInt()}%")
+            if (speedText.isNotEmpty()) {
+                append(" · $speedText")
+            }
+        }
+
+        return NotificationCompat.Builder(this, DOWNLOAD_CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_launcher_foreground)
+            .setContentTitle(title)
+            .setContentText(contentText)
+            .setProgress(100, percent.toInt(), false)
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .build()
+    }
+
+    override fun getScheduler(): Scheduler? = null
+
+    private fun formatSpeed(bytesPerSec: Long): String {
+        if (bytesPerSec <= 0) return ""
+        return when {
+            bytesPerSec >= 1_000_000 -> String.format("%.1f MB/s", bytesPerSec / 1_000_000.0)
+            bytesPerSec >= 1_000 -> String.format("%.0f KB/s", bytesPerSec / 1_000.0)
+            else -> "$bytesPerSec B/s"
+        }
+    }
+
+    companion object {
+        private const val FOREGROUND_NOTIFICATION_ID = 1
+        private const val DOWNLOAD_CHANNEL_ID = "purefin_downloads"
+
+        fun sendAddDownload(context: Context, request: DownloadRequest) {
+            sendAddDownload(
+                context,
+                PurefinDownloadService::class.java,
+                request,
+                false
+            )
+        }
+
+        fun sendRemoveDownload(context: Context, contentId: String) {
+            sendRemoveDownload(
+                context,
+                PurefinDownloadService::class.java,
+                contentId,
+                false
+            )
+        }
+    }
+}
--- a/feature/download/src/main/res/drawable/ic_launcher_foreground.xml
+++ b/feature/download/src/main/res/drawable/ic_launcher_foreground.xml
@@ -0,0 +1,30 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="85.84757"
+                android:endY="92.4963"
+                android:startX="42.9492"
+                android:startY="49.59793"
+                android:type="linear">
+                <item
+                    android:color="#44000000"
+                    android:offset="0.0" />
+                <item
+                    android:color="#00000000"
+                    android:offset="1.0" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#FFFFFF"
+        android:fillType="nonZero"
+        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000" />
+</vector>
--- a/feature/download/src/main/res/values/strings.xml
+++ b/feature/download/src/main/res/values/strings.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="download_channel_name">Downloads</string>
+    <string name="download_channel_description">Media download progress</string>
+</resources>
--- a/feature/shared/build.gradle.kts
+++ b/feature/shared/build.gradle.kts
@@ -0,0 +1,38 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.hilt)
+    alias(libs.plugins.ksp)
+}
+
+android {
+    namespace = "hu.bbara.purefin.feature.shared"
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 29
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
+    }
+}
+
+dependencies {
+    implementation(project(":core:model"))
+    implementation(project(":core:data"))
+    implementation(project(":feature:download"))
+    implementation(libs.hilt)
+    ksp(libs.hilt.compiler)
+    implementation(libs.jellyfin.core)
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/episode/EpisodeModels.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/episode/EpisodeModels.kt
@@ -0,0 +1,25 @@
+package hu.bbara.purefin.feature.shared.content.episode
+
+import org.jellyfin.sdk.model.UUID
+
+data class CastMember(
+    val name: String,
+    val role: String,
+    val imageUrl: String?
+)
+
+data class EpisodeUiModel(
+    val id: UUID,
+    val title: String,
+    val seasonNumber: Int,
+    val episodeNumber: Int,
+    val releaseDate: String,
+    val rating: String,
+    val runtime: String,
+    val format: String,
+    val synopsis: String,
+    val heroImageUrl: String,
+    val audioTrack: String,
+    val subtitles: String,
+    val cast: List<CastMember>
+)
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/episode/EpisodeScreenViewModel.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/episode/EpisodeScreenViewModel.kt
@@ -0,0 +1,45 @@
+package hu.bbara.purefin.feature.shared.content.episode
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import hu.bbara.purefin.core.data.MediaRepository
+import hu.bbara.purefin.core.data.navigation.NavigationManager
+import hu.bbara.purefin.core.model.Episode
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import org.jellyfin.sdk.model.UUID
+import javax.inject.Inject
+
+@HiltViewModel
+class EpisodeScreenViewModel @Inject constructor(
+    private val mediaRepository: MediaRepository,
+    private val navigationManager: NavigationManager,
+): ViewModel() {
+
+    private val _episodeId = MutableStateFlow<UUID?>(null)
+
+    val episode: StateFlow<Episode?> = combine(
+        _episodeId,
+        mediaRepository.episodes
+    ) { id, episodesMap ->
+        id?.let { episodesMap[it] }
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
+
+    init {
+        viewModelScope.launch { mediaRepository.ensureReady() }
+    }
+
+    fun onBack() {
+        navigationManager.pop()
+    }
+
+    fun selectEpisode(seriesId: UUID, seasonId: UUID, episodeId: UUID) {
+        _episodeId.value = episodeId
+    }
+
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/movie/MovieModels.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/movie/MovieModels.kt
@@ -0,0 +1,24 @@
+package hu.bbara.purefin.feature.shared.content.movie
+
+import org.jellyfin.sdk.model.UUID
+
+data class CastMember(
+    val name: String,
+    val role: String,
+    val imageUrl: String?
+)
+
+data class MovieUiModel(
+    val id: UUID,
+    val title: String,
+    val year: String,
+    val rating: String,
+    val runtime: String,
+    val format: String,
+    val synopsis: String,
+    val heroImageUrl: String,
+    val audioTrack: String,
+    val subtitles: String,
+    val progress: Double?,
+    val cast: List<CastMember>
+)
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/movie/MovieScreenViewModel.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/movie/MovieScreenViewModel.kt
@@ -0,0 +1,92 @@
+package hu.bbara.purefin.feature.shared.content.movie
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import hu.bbara.purefin.core.data.MediaRepository
+import hu.bbara.purefin.core.data.navigation.NavigationManager
+import hu.bbara.purefin.core.data.navigation.Route
+import hu.bbara.purefin.core.model.Movie
+import hu.bbara.purefin.feature.download.DownloadState
+import hu.bbara.purefin.feature.download.MediaDownloadManager
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import org.jellyfin.sdk.model.UUID
+import javax.inject.Inject
+
+@HiltViewModel
+class MovieScreenViewModel @Inject constructor(
+    private val mediaRepository: MediaRepository,
+    private val navigationManager: NavigationManager,
+    private val mediaDownloadManager: MediaDownloadManager
+): ViewModel() {
+
+    private val _movie = MutableStateFlow<MovieUiModel?>(null)
+    val movie = _movie.asStateFlow()
+
+    private val _downloadState = MutableStateFlow<DownloadState>(DownloadState.NotDownloaded)
+    val downloadState: StateFlow<DownloadState> = _downloadState.asStateFlow()
+
+    fun onBack() {
+        navigationManager.pop()
+    }
+
+
+    fun onGoHome() {
+        navigationManager.replaceAll(Route.Home)
+    }
+
+    fun selectMovie(movieId: UUID) {
+        viewModelScope.launch {
+            val movieData = mediaRepository.movies.value[movieId]
+            if (movieData == null) {
+                _movie.value = null
+                return@launch
+            }
+            _movie.value = movieData.toUiModel()
+
+            launch {
+                mediaDownloadManager.observeDownloadState(movieId.toString()).collect {
+                    _downloadState.value = it
+                }
+            }
+        }
+    }
+
+    fun onDownloadClick() {
+        val movieId = _movie.value?.id ?: return
+        viewModelScope.launch {
+            when (_downloadState.value) {
+                is DownloadState.NotDownloaded, is DownloadState.Failed -> {
+                    mediaDownloadManager.downloadMovie(movieId)
+                }
+                is DownloadState.Downloading -> {
+                    mediaDownloadManager.cancelDownload(movieId)
+                }
+                is DownloadState.Downloaded -> {
+                    mediaDownloadManager.cancelDownload(movieId)
+                }
+            }
+        }
+    }
+
+    private fun Movie.toUiModel(): MovieUiModel {
+        return MovieUiModel(
+            id = id,
+            title = title,
+            year = year,
+            rating = rating,
+            runtime = runtime,
+            format = format,
+            synopsis = synopsis,
+            heroImageUrl = heroImageUrl,
+            audioTrack = audioTrack,
+            subtitles = subtitles,
+            progress = progress,
+            cast = cast.map { CastMember(name = it.name, role = it.role, imageUrl = it.imageUrl) }
+        )
+    }
+
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/series/SeriesModels.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/series/SeriesModels.kt
@@ -0,0 +1,48 @@
+package hu.bbara.purefin.feature.shared.content.series
+
+data class SeriesEpisodeUiModel(
+    val id: String,
+    val title: String,
+    val seasonNumber: Int,
+    val episodeNumber: Int,
+    val description: String,
+    val duration: String,
+    val imageUrl: String,
+    val watched: Boolean,
+    val progress: Double?
+)
+
+data class SeriesSeasonUiModel(
+    val name: String,
+    val episodes: List<SeriesEpisodeUiModel>,
+    val unplayedCount: Int?
+)
+
+data class SeriesCastMemberUiModel(
+    val name: String,
+    val role: String,
+    val imageUrl: String?
+)
+
+data class SeriesUiModel(
+    val title: String,
+    val year: String,
+    val rating: String,
+    val seasons: String,
+    val format: String,
+    val synopsis: String,
+    val heroImageUrl: String,
+    val seasonTabs: List<SeriesSeasonUiModel>,
+    val cast: List<SeriesCastMemberUiModel>
+) {
+    fun getNextEpisode(): SeriesEpisodeUiModel {
+        for (season in seasonTabs) {
+            for (episode in season.episodes) {
+                if (!episode.watched) {
+                    return episode
+                }
+            }
+        }
+        return seasonTabs.first().episodes.first()
+    }
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/series/SeriesViewModel.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/content/series/SeriesViewModel.kt
@@ -0,0 +1,64 @@
+package hu.bbara.purefin.feature.shared.content.series
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import hu.bbara.purefin.core.data.MediaRepository
+import hu.bbara.purefin.core.data.navigation.EpisodeDto
+import hu.bbara.purefin.core.data.navigation.NavigationManager
+import hu.bbara.purefin.core.data.navigation.Route
+import hu.bbara.purefin.core.model.Series
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+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 kotlinx.coroutines.launch
+import org.jellyfin.sdk.model.UUID
+import javax.inject.Inject
+
+@HiltViewModel
+class SeriesViewModel @Inject constructor(
+    private val mediaRepository: MediaRepository,
+    private val navigationManager: NavigationManager,
+) : ViewModel() {
+
+    private val _seriesId = MutableStateFlow<UUID?>(null)
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val series: StateFlow<Series?> = _seriesId
+        .flatMapLatest { id ->
+            if (id != null) mediaRepository.observeSeriesWithContent(id) else flowOf(null)
+        }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
+
+    init {
+        viewModelScope.launch { mediaRepository.ensureReady() }
+    }
+
+    fun onSelectEpisode(seriesId: UUID, seasonId:UUID, episodeId: UUID) {
+        viewModelScope.launch {
+            navigationManager.navigate(Route.EpisodeRoute(
+                EpisodeDto(
+                    id = episodeId,
+                    seasonId = seasonId,
+                    seriesId = seriesId
+                )
+            ))
+        }
+    }
+
+    fun onBack() {
+        navigationManager.pop()
+    }
+
+    fun onGoHome() {
+        navigationManager.replaceAll(Route.Home)
+    }
+
+    fun selectSeries(seriesId: UUID) {
+        _seriesId.value = seriesId
+    }
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/home/HomeModels.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/home/HomeModels.kt
@@ -0,0 +1,81 @@
+package hu.bbara.purefin.feature.shared.home
+
+import hu.bbara.purefin.core.model.Episode
+import hu.bbara.purefin.core.model.Movie
+import hu.bbara.purefin.core.model.Series
+import org.jellyfin.sdk.model.UUID
+import org.jellyfin.sdk.model.api.BaseItemKind
+import org.jellyfin.sdk.model.api.CollectionType
+
+data class ContinueWatchingItem(
+    val type: BaseItemKind,
+    val movie: Movie? = null,
+    val episode: Episode? = null
+) {
+    val id: UUID = when (type) {
+        BaseItemKind.MOVIE -> movie!!.id
+        BaseItemKind.EPISODE -> episode!!.id
+        else -> throw UnsupportedOperationException("Unsupported item type: $type")
+    }
+    val primaryText: String = when (type) {
+        BaseItemKind.MOVIE -> movie!!.title
+        BaseItemKind.EPISODE -> episode!!.title
+        else -> throw UnsupportedOperationException("Unsupported item type: $type")
+    }
+    val secondaryText: String = when (type) {
+        BaseItemKind.MOVIE -> movie!!.year
+        BaseItemKind.EPISODE -> episode!!.releaseDate
+        else -> throw UnsupportedOperationException("Unsupported item type: $type")
+    }
+    val progress: Double = when (type) {
+        BaseItemKind.MOVIE -> movie!!.progress ?: 0.0
+        BaseItemKind.EPISODE -> episode!!.progress ?: 0.0
+        else -> throw UnsupportedOperationException("Unsupported item type: $type")
+    }
+}
+
+data class NextUpItem(
+    val episode: Episode
+) {
+    val id: UUID = episode.id
+    val primaryText: String = episode.title
+    val secondaryText: String = episode.releaseDate
+}
+
+data class LibraryItem(
+    val id: UUID,
+    val name: String,
+    val type: CollectionType,
+    val isEmpty: Boolean
+)
+
+data class PosterItem(
+    val type: BaseItemKind,
+    val movie: Movie? = null,
+    val series: Series? = null,
+    val episode: Episode? = null
+) {
+    val id: UUID = when (type) {
+        BaseItemKind.MOVIE -> movie!!.id
+        BaseItemKind.EPISODE -> episode!!.id
+        BaseItemKind.SERIES -> series!!.id
+        else -> throw IllegalArgumentException("Invalid type: $type")
+    }
+    val title: String = when (type) {
+        BaseItemKind.MOVIE -> movie!!.title
+        BaseItemKind.EPISODE -> episode!!.title
+        BaseItemKind.SERIES -> series!!.name
+        else -> throw IllegalArgumentException("Invalid type: $type")
+    }
+    val imageUrl: String = when (type) {
+        BaseItemKind.MOVIE -> movie!!.heroImageUrl
+        BaseItemKind.EPISODE -> episode!!.heroImageUrl
+        BaseItemKind.SERIES -> series!!.heroImageUrl
+        else -> throw IllegalArgumentException("Invalid type: $type")
+    }
+    fun watched() = when (type) {
+        BaseItemKind.MOVIE -> movie!!.watched
+        BaseItemKind.EPISODE -> episode!!.watched
+        else -> throw IllegalArgumentException("Invalid type: $type")
+    }
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/home/HomePageViewModel.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/home/HomePageViewModel.kt
@@ -0,0 +1,213 @@
+package hu.bbara.purefin.feature.shared.home
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import hu.bbara.purefin.core.data.MediaRepository
+import hu.bbara.purefin.core.model.Media
+import hu.bbara.purefin.core.data.domain.usecase.RefreshHomeDataUseCase
+import hu.bbara.purefin.core.data.image.JellyfinImageHelper
+import hu.bbara.purefin.core.data.navigation.EpisodeDto
+import hu.bbara.purefin.core.data.navigation.LibraryDto
+import hu.bbara.purefin.core.data.navigation.MovieDto
+import hu.bbara.purefin.core.data.navigation.NavigationManager
+import hu.bbara.purefin.core.data.navigation.Route
+import hu.bbara.purefin.core.data.navigation.SeriesDto
+import hu.bbara.purefin.core.data.session.UserSessionRepository
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import org.jellyfin.sdk.model.UUID
+import org.jellyfin.sdk.model.api.BaseItemKind
+import org.jellyfin.sdk.model.api.CollectionType
+import org.jellyfin.sdk.model.api.ImageType
+import javax.inject.Inject
+
+@HiltViewModel
+class HomePageViewModel @Inject constructor(
+    private val mediaRepository: MediaRepository,
+    private val userSessionRepository: UserSessionRepository,
+    private val navigationManager: NavigationManager,
+    private val refreshHomeDataUseCase: RefreshHomeDataUseCase
+) : ViewModel() {
+
+    private val _url = userSessionRepository.serverUrl.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.Eagerly,
+        initialValue = ""
+    )
+
+    val libraries = mediaRepository.libraries.map { libraries ->
+        libraries.map {
+            LibraryItem(
+                id = it.id,
+                name = it.name,
+                type = it.type,
+                isEmpty = when(it.type) {
+                    CollectionType.MOVIES -> mediaRepository.movies.value.isEmpty()
+                    CollectionType.TVSHOWS -> mediaRepository.series.value.isEmpty()
+                    else -> true
+                }
+            )
+        }
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
+    val isOfflineMode = userSessionRepository.isOfflineMode.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.Eagerly,
+        initialValue = false
+    )
+
+    val continueWatching = combine(
+        mediaRepository.continueWatching,
+        mediaRepository.movies,
+        mediaRepository.episodes
+    ) { list, moviesMap, episodesMap ->
+        list.mapNotNull { media ->
+            when (media) {
+                is Media.MovieMedia -> moviesMap[media.movieId]?.let {
+                    ContinueWatchingItem(type = BaseItemKind.MOVIE, movie = it)
+                }
+                is Media.EpisodeMedia -> episodesMap[media.episodeId]?.let {
+                    ContinueWatchingItem(type = BaseItemKind.EPISODE, episode = it)
+                }
+                else -> null
+            }
+        }.distinctBy { it.id }
+    }.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000),
+        initialValue = emptyList()
+    )
+
+    val nextUp = combine(
+        mediaRepository.nextUp,
+        mediaRepository.episodes
+    ) { list, episodesMap ->
+        list.mapNotNull { media ->
+            when (media) {
+                is Media.EpisodeMedia -> episodesMap[media.episodeId]?.let {
+                    NextUpItem(episode = it)
+                }
+                else -> null
+            }
+        }.distinctBy { it.id }
+    }.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000),
+        initialValue = emptyList()
+    )
+
+    val latestLibraryContent = combine(
+        mediaRepository.latestLibraryContent,
+        mediaRepository.movies,
+        mediaRepository.series,
+        mediaRepository.episodes
+    ) { libraryMap, moviesMap, seriesMap, episodesMap ->
+        libraryMap.mapValues { (_, items) ->
+            items.mapNotNull { media ->
+                when (media) {
+                    is Media.MovieMedia -> moviesMap[media.movieId]?.let {
+                        PosterItem(type = BaseItemKind.MOVIE, movie = it)
+                    }
+                    is Media.EpisodeMedia -> episodesMap[media.episodeId]?.let {
+                        PosterItem(type = BaseItemKind.EPISODE, episode = it)
+                    }
+                    is Media.SeriesMedia -> seriesMap[media.seriesId]?.let {
+                        PosterItem(type = BaseItemKind.SERIES, series = it)
+                    }
+                    is Media.SeasonMedia -> seriesMap[media.seriesId]?.let {
+                        PosterItem(type = BaseItemKind.SERIES, series = it)
+                    }
+                    else -> null
+                }
+            }.distinctBy { it.id }
+        }
+    }.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000),
+        initialValue = emptyMap()
+    )
+
+    init {
+        viewModelScope.launch { mediaRepository.ensureReady() }
+    }
+
+    fun onLibrarySelected(id: UUID, name: String) {
+        viewModelScope.launch {
+            navigationManager.navigate(Route.LibraryRoute(library = LibraryDto(id = id, name = name)))
+        }
+    }
+
+    fun onMovieSelected(movieId: UUID) {
+        navigationManager.navigate(Route.MovieRoute(
+            MovieDto(
+                id = movieId,
+            )
+        ))
+    }
+
+    fun onSeriesSelected(seriesId: UUID) {
+        viewModelScope.launch {
+            navigationManager.navigate(Route.SeriesRoute(
+                SeriesDto(
+                    id = seriesId,
+                )
+            ))
+        }
+    }
+
+    fun onEpisodeSelected(seriesId: UUID, seasonId: UUID, episodeId: UUID) {
+        viewModelScope.launch {
+            navigationManager.navigate(Route.EpisodeRoute(
+                EpisodeDto(
+                    id = episodeId,
+                    seasonId = seasonId,
+                    seriesId = seriesId
+                )
+            ))
+        }
+    }
+
+    fun onBack() {
+        navigationManager.pop()
+    }
+
+
+    fun onGoHome() {
+        navigationManager.replaceAll(Route.Home)
+    }
+
+    fun getImageUrl(itemId: UUID, type: ImageType): String {
+        return JellyfinImageHelper.toImageUrl(
+            url = _url.value,
+            itemId = itemId,
+            type = type
+        )
+    }
+
+    fun onResumed() {
+        viewModelScope.launch {
+            try {
+                refreshHomeDataUseCase()
+            } catch (e: Exception) {
+                // Refresh is best-effort; don't crash on failure
+            }
+        }
+    }
+
+    fun logout() {
+        viewModelScope.launch {
+            userSessionRepository.setLoggedIn(false)
+        }
+    }
+
+    fun toggleOfflineMode() {
+        viewModelScope.launch {
+            userSessionRepository.setOfflineMode(!isOfflineMode.value)
+        }
+    }
+
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/library/LibraryViewModel.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/library/LibraryViewModel.kt
@@ -0,0 +1,79 @@
+package hu.bbara.purefin.feature.shared.library
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import hu.bbara.purefin.feature.shared.home.PosterItem
+import hu.bbara.purefin.core.data.MediaRepository
+import hu.bbara.purefin.core.data.navigation.MovieDto
+import hu.bbara.purefin.core.data.navigation.NavigationManager
+import hu.bbara.purefin.core.data.navigation.Route
+import hu.bbara.purefin.core.data.navigation.SeriesDto
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import org.jellyfin.sdk.model.UUID
+import org.jellyfin.sdk.model.api.BaseItemKind
+import org.jellyfin.sdk.model.api.CollectionType
+import javax.inject.Inject
+
+@HiltViewModel
+class LibraryViewModel @Inject constructor(
+    private val mediaRepository: MediaRepository,
+    private val navigationManager: NavigationManager
+) : ViewModel() {
+
+    private val selectedLibrary = MutableStateFlow<UUID?>(null)
+
+    val contents: StateFlow<List<PosterItem>> = combine(selectedLibrary, mediaRepository.libraries) {
+        libraryId, libraries ->
+        if (libraryId == null) {
+            return@combine emptyList()
+        }
+        val library = libraries.find { it.id == libraryId } ?: return@combine emptyList()
+        when (library.type) {
+            CollectionType.TVSHOWS -> library.series!!.map { series ->
+                PosterItem(type = BaseItemKind.SERIES, series = series)
+            }
+            CollectionType.MOVIES -> library.movies!!.map { movie ->
+                PosterItem(type = BaseItemKind.MOVIE, movie = movie)
+            }
+            else -> emptyList()
+        }
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
+    init {
+        viewModelScope.launch { mediaRepository.ensureReady() }
+    }
+
+    fun onMovieSelected(movieId: UUID) {
+        navigationManager.navigate(Route.MovieRoute(
+            MovieDto(
+                id = movieId,
+            )
+        ))
+    }
+
+    fun onSeriesSelected(seriesId: UUID) {
+        viewModelScope.launch {
+            navigationManager.navigate(Route.SeriesRoute(
+                SeriesDto(
+                    id = seriesId,
+                )
+            ))
+        }
+    }
+
+    fun onBack() {
+        navigationManager.pop()
+    }
+
+    fun selectLibrary(libraryId: UUID) {
+        viewModelScope.launch {
+            selectedLibrary.value = libraryId
+        }
+    }
+}
--- a/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/login/LoginViewModel.kt
+++ b/feature/shared/src/main/java/hu/bbara/purefin/feature/shared/login/LoginViewModel.kt
@@ -0,0 +1,67 @@
+package hu.bbara.purefin.feature.shared.login
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import hu.bbara.purefin.core.data.client.JellyfinApiClient
+import hu.bbara.purefin.core.data.session.UserSessionRepository
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@HiltViewModel
+class LoginViewModel @Inject constructor(
+    private val userSessionRepository: UserSessionRepository,
+    private val jellyfinApiClient: JellyfinApiClient,
+) : ViewModel() {
+    private val _username = MutableStateFlow("")
+    val username: StateFlow<String> = _username.asStateFlow()
+    private val _password = MutableStateFlow("")
+    val password: StateFlow<String> = _password.asStateFlow()
+    private val _url = MutableStateFlow("")
+    val url: StateFlow<String> = _url.asStateFlow()
+    private val _errorMessage = MutableStateFlow<String?>(null)
+    val errorMessage: StateFlow<String?> = _errorMessage.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            _url.value = userSessionRepository.serverUrl.first()
+        }
+    }
+
+    fun setUrl(url: String) {
+        _url.value = url
+    }
+
+    fun setUsername(username: String) {
+        _username.value = username
+    }
+
+    fun setPassword(password: String) {
+        _password.value = password
+    }
+
+    fun clearError() {
+        _errorMessage.value = null
+    }
+
+    suspend fun clearFields() {
+        userSessionRepository.setServerUrl("");
+        _username.value = ""
+        _password.value = ""
+    }
+
+    suspend fun login(): Boolean {
+        _errorMessage.value = null
+        userSessionRepository.setServerUrl(url.value)
+        val success = jellyfinApiClient.login(url.value, username.value, password.value)
+        if (!success) {
+            _errorMessage.value = "Login failed. Check your server URL, username, and password."
+        }
+        return success
+    }
+
+}