New Feature: Introduce Upcoming page to Mihon

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -66,6 +66,7 @@ import tachiyomi.domain.manga.interactor.GetLibraryManga
 import tachiyomi.domain.manga.interactor.GetManga
 import tachiyomi.domain.manga.interactor.GetMangaByUrlAndSourceId
 import tachiyomi.domain.manga.interactor.GetMangaWithChapters
+import tachiyomi.domain.manga.interactor.GetUpcomingManga
 import tachiyomi.domain.manga.interactor.NetworkToLocalManga
 import tachiyomi.domain.manga.interactor.ResetViewerFlags
 import tachiyomi.domain.manga.interactor.SetMangaChapterFlags
@@ -111,6 +112,7 @@ class DomainModule : InjektModule {
         addFactory { GetMangaByUrlAndSourceId(get()) }
         addFactory { GetManga(get()) }
         addFactory { GetNextChapters(get(), get(), get()) }
+        addFactory { GetUpcomingManga(get()) }
         addFactory { ResetViewerFlags(get()) }
         addFactory { SetMangaChapterFlags(get()) }
         addFactory { FetchInterval(get()) }

app/src/main/java/eu/kanade/presentation/updates/UpcomingItem.kt

@@ -0,0 +1,58 @@
+package eu.kanade.presentation.updates
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import eu.kanade.presentation.manga.components.MangaCover
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.model.asMangaCover
+import tachiyomi.presentation.core.components.material.padding
+
+private val UpcomingItemHeight = 96.dp
+
+@Composable
+fun UpcomingItem(
+    upcoming: Manga,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier
+            .clickable(onClick = onClick)
+            .height(UpcomingItemHeight)
+            .padding(
+                horizontal = MaterialTheme.padding.medium,
+                vertical = MaterialTheme.padding.small,
+            ),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        MangaCover.Book(
+            modifier = Modifier.fillMaxHeight(),
+            data = upcoming.asMangaCover(),
+        )
+
+        Text(
+            modifier = Modifier
+                .weight(1f)
+                .padding(
+                    start = MaterialTheme.padding.large,
+                    end = MaterialTheme.padding.small,
+                ),
+            text = upcoming.title,
+            fontWeight = FontWeight.SemiBold,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+            style = MaterialTheme.typography.bodyMedium,
+        )
+    }
+}

app/src/main/java/eu/kanade/presentation/updates/UpdateUpcomingScreen.kt

@@ -0,0 +1,288 @@
+package eu.kanade.presentation.updates
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.calculateEndPadding
+import androidx.compose.foundation.layout.calculateStartPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.HelpOutline
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.unit.dp
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.components.AppBarTitle
+import eu.kanade.presentation.components.UpIcon
+import eu.kanade.presentation.components.relativeDateText
+import eu.kanade.presentation.updates.components.calendar.Calendar
+import eu.kanade.presentation.util.isTabletUi
+import eu.kanade.tachiyomi.ui.updates.UpdateUpcomingScreenModel
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.ImmutableMap
+import kotlinx.collections.immutable.persistentMapOf
+import kotlinx.coroutines.launch
+import tachiyomi.core.common.Constants
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.FastScrollLazyColumn
+import tachiyomi.presentation.core.components.ListGroupHeader
+import tachiyomi.presentation.core.components.TwoPanelBox
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.i18n.stringResource
+import java.time.LocalDate
+
+@Composable
+fun UpdateUpcomingScreen(
+    onClickUpcoming: (manga: Manga) -> Unit,
+    state: UpdateUpcomingScreenModel.State,
+    modifier: Modifier = Modifier,
+) {
+    if (isTabletUi()) {
+        UpdateUpcomingScreenLargeImpl(
+            state = state,
+            modifier = modifier,
+            onClickUpcoming = onClickUpcoming,
+        )
+    } else {
+        UpdateUpcomingScreenSmallImpl(
+            state = state,
+            modifier = modifier,
+            onClickUpcoming = onClickUpcoming,
+        )
+    }
+}
+
+@Composable
+internal fun UpdateUpcomingScreenSmallImpl(
+    onClickUpcoming: (manga: Manga) -> Unit,
+    state: UpdateUpcomingScreenModel.State,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier,
+        topBar = { UpdateUpcomingToolbar() },
+    ) { paddingValues ->
+        UpdateUpcomingSmallContent(
+            upcoming = state.items,
+            events = state.events,
+            contentPadding = paddingValues,
+            onClickUpcoming = onClickUpcoming,
+        )
+    }
+}
+
+@Composable
+internal fun UpdateUpcomingToolbar(
+    modifier: Modifier = Modifier,
+) {
+    val navigator = LocalNavigator.currentOrThrow
+    Column(
+        modifier = modifier,
+    ) {
+        TopAppBar(
+            navigationIcon = {
+                IconButton(onClick = navigator::pop) {
+                    UpIcon()
+                }
+            },
+            title = { AppBarTitle(stringResource(MR.strings.label_upcoming)) },
+            actions = {
+                val uriHandler = LocalUriHandler.current
+                IconButton(onClick = { uriHandler.openUri(Constants.URL_HELP_UPCOMING) }) {
+                    Icon(
+                        imageVector = Icons.AutoMirrored.Outlined.HelpOutline,
+                        contentDescription = stringResource(MR.strings.upcoming_guide),
+                    )
+                }
+            },
+        )
+    }
+}
+
+@Composable
+internal fun UpdateUpcomingSmallContent(
+    contentPadding: PaddingValues,
+    onClickUpcoming: (manga: Manga) -> Unit,
+    upcoming: ImmutableList<UpcomingUIModel>,
+    modifier: Modifier = Modifier,
+    events: ImmutableMap<LocalDate, Int> = persistentMapOf(),
+) {
+    val listState = rememberLazyListState()
+    val coroutineScope = rememberCoroutineScope()
+
+    val dateToHeaderMap =
+        upcoming.withIndex()
+            .filter { it.value is UpcomingUIModel.Header }
+            .associate { Pair((it.value as UpcomingUIModel.Header).date, it.index + 1) } // Offset 1 for Calendar
+
+    val configuration = LocalConfiguration.current
+
+    FastScrollLazyColumn(
+        contentPadding = contentPadding,
+        state = listState,
+        modifier = modifier,
+    ) {
+        item(
+            key = "upcoming-calendar",
+        ) {
+            Calendar(
+                events = events,
+                screenWidth = configuration.screenWidthDp.dp,
+            ) { date ->
+                dateToHeaderMap[date]?.let {
+                    coroutineScope.launch {
+                        listState.animateScrollToItem(it)
+                    }
+                }
+            }
+        }
+        items(
+            items = upcoming,
+            key = { "upcoming-${it.hashCode()}" },
+            contentType = {
+                when (it) {
+                    is UpcomingUIModel.Header -> "header"
+                    is UpcomingUIModel.Item -> "item"
+                }
+            },
+        ) { item ->
+            when (item) {
+                is UpcomingUIModel.Item -> {
+                    UpcomingItem(
+                        upcoming = item.item,
+                        onClick = { onClickUpcoming(item.item) },
+                    )
+                }
+                is UpcomingUIModel.Header -> {
+                    ListGroupHeader(
+                        modifier = Modifier.animateItemPlacement(),
+                        text = relativeDateText(item.date),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+internal fun UpdateUpcomingScreenLargeImpl(
+    state: UpdateUpcomingScreenModel.State,
+    modifier: Modifier = Modifier,
+    onClickUpcoming: (manga: Manga) -> Unit = {},
+) {
+    val layoutDirection = LocalLayoutDirection.current
+    val listState = rememberLazyListState()
+
+    Scaffold(
+        modifier = modifier,
+        topBar = { UpdateUpcomingToolbar() },
+    ) { contentPadding ->
+        TwoPanelBox(
+            modifier = Modifier.padding(
+                start = contentPadding.calculateStartPadding(layoutDirection),
+                end = contentPadding.calculateEndPadding(layoutDirection),
+            ),
+            startContent = {
+                UpdateUpcomingLargeCalendar(
+                    upcoming = state.items,
+                    listState = listState,
+                    events = state.events,
+                    modifier = Modifier.padding(contentPadding),
+                )
+            },
+            endContent = {
+                UpdateUpcomingLargeContent(
+                    upcoming = state.items,
+                    listState = listState,
+                    contentPadding = contentPadding,
+                    onClickUpcoming = onClickUpcoming,
+                )
+            },
+        )
+    }
+}
+
+@Composable
+internal fun UpdateUpcomingLargeCalendar(
+    upcoming: ImmutableList<UpcomingUIModel>,
+    listState: LazyListState,
+    modifier: Modifier = Modifier,
+    events: ImmutableMap<LocalDate, Int> = persistentMapOf(),
+) {
+    val configuration = LocalConfiguration.current
+    val coroutineScope = rememberCoroutineScope()
+
+    val dateToHeaderMap =
+        upcoming.withIndex()
+            .filter { it.value is UpcomingUIModel.Header }
+            .associate { Pair((it.value as UpcomingUIModel.Header).date, it.index) }
+
+    Calendar(
+        modifier = modifier,
+        events = events,
+        screenWidth = configuration.screenWidthDp.dp,
+    ) { date ->
+        dateToHeaderMap[date]?.let {
+            coroutineScope.launch {
+                listState.animateScrollToItem(it)
+            }
+        }
+    }
+}
+
+@Composable
+internal fun UpdateUpcomingLargeContent(
+    upcoming: ImmutableList<UpcomingUIModel>,
+    listState: LazyListState,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+    onClickUpcoming: (manga: Manga) -> Unit,
+) {
+    FastScrollLazyColumn(
+        contentPadding = contentPadding,
+        state = listState,
+        modifier = modifier,
+    ) {
+        items(
+            items = upcoming,
+            key = { "upcoming-${it.hashCode()}" },
+            contentType = {
+                when (it) {
+                    is UpcomingUIModel.Header -> "header"
+                    is UpcomingUIModel.Item -> "item"
+                }
+            },
+        ) { item ->
+            when (item) {
+                is UpcomingUIModel.Item -> {
+                    UpcomingItem(
+                        upcoming = item.item,
+                        onClick = { onClickUpcoming(item.item) },
+                    )
+                }
+                is UpcomingUIModel.Header -> {
+                    ListGroupHeader(
+                        modifier = Modifier.animateItemPlacement(),
+                        text = relativeDateText(item.date),
+                    )
+                }
+            }
+        }
+    }
+}
+
+sealed interface UpcomingUIModel {
+    data class Header(val date: LocalDate) : UpcomingUIModel
+    data class Item(val item: Manga) : UpcomingUIModel
+}