R813: keep reader content in the tabletop upper region (#920)

Co-authored-by: ryacub <ryacub@users.noreply.github.com>

Author: ryacub

CHANGELOG.md

@@ -13,6 +13,7 @@ The format is a modified version of [Keep a Changelog](https://keepachangelog.co
 ## Unreleased
 
 ### Added
+- The reader keeps content in the upper region during tabletop posture. The reader restores the normal layout when the device leaves tabletop posture.
 - Library search comparison parsing now uses only documented aliases. The help explains that malformed comparison values never match and that negating one matches every entry.
 - Library search now supports the comparison fields `id`, `added`, `fetchinterval` (or `fi`), `nextupdate` (or `nu`), `unread`, `read`, and `total` with the operators `>=`, `<=`, `>`, `<`, and `=`; dates use the `yyyy-MM-dd` format. The `language:` (or `lang:`) field filters by source language, and the `notes:` (or `note:`) field is not supported. For anime, `unread` means unseen, `read` means seen, and `total` means total episodes.
 - Library search now supports the operators `&&` (AND), `||` (OR), and `-` (NOT), grouped expressions with parentheses, and double-quoted values. Field filters search by `title`, `author`, `artist`, `description` (or `desc`), `genre` (or `tag`), and `source` (or `src`); the `source:local` value matches local entries. Queries without these markers keep the old behavior, including comma lists, a leading minus, and the `id:` prefix. The new Search help item in the library menu explains the syntax.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt

@@ -34,6 +34,7 @@ import androidx.core.content.getSystemService
 import androidx.core.graphics.ColorUtils
 import androidx.core.net.toUri
 import androidx.core.transition.doOnEnd
+import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
@@ -55,6 +56,10 @@ import eu.kanade.presentation.reader.ReaderPageActionsDialog
 import eu.kanade.presentation.reader.ReadingModeSelectDialog
 import eu.kanade.presentation.reader.appbars.ReaderAppBars
 import eu.kanade.presentation.reader.settings.ReaderSettingsDialog
+import eu.kanade.presentation.util.FoldOcclusionType
+import eu.kanade.presentation.util.FoldOrientation
+import eu.kanade.presentation.util.FoldState
+import eu.kanade.presentation.util.ReaderFoldState
 import eu.kanade.presentation.util.readerFoldStateFrom
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.core.common.Constants
@@ -282,6 +287,18 @@ class ReaderActivity : BaseActivity() {
                     .collect(viewModel::setFoldState)
             }
         }
+
+        // Single source of truth for the tabletop upper-region constraint.
+        // updateViewer() replaces the viewer on the main thread, and the next
+        // fold-state emission applies the constraint to the current viewer.
+        viewModel.state
+            .map { it.foldState }
+            .distinctUntilChanged()
+            .onEach(::updateViewerForTabletopPosture)
+            .launchIn(lifecycleScope)
+
+        // Close the startup gap before the observer's first emission.
+        updateViewerForTabletopPosture(viewModel.state.value.foldState)
     }
 
     /**
@@ -887,6 +904,27 @@ class ReaderActivity : BaseActivity() {
         }
     }
 
+    /**
+     * Constrains the viewer height for the tabletop upper region.
+     *
+     * It runs on the fold state that the [ReaderViewModel.State.foldState]
+     * observer emits. It reads the status bar inset from the viewer view so
+     * the height is measured in content coordinates.
+     */
+    private fun updateViewerForTabletopPosture(foldState: ReaderFoldState?) {
+        val view = viewModel.state.value.viewer?.getView() ?: return
+        val statusBarInset = ViewCompat.getRootWindowInsets(view)
+            ?.getInsets(WindowInsetsCompat.Type.statusBars())?.top ?: 0
+        val tabletopHeight = tabletopViewerHeight(foldState, statusBarInset)
+        val params = view.layoutParams as? FrameLayout.LayoutParams
+            ?: FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT,
+            )
+        params.height = tabletopHeight ?: FrameLayout.LayoutParams.MATCH_PARENT
+        view.layoutParams = params
+    }
+
     /**
      * Class that observes ReaderConfigManager and applies config to Android Window/Views.
      */
@@ -972,3 +1010,32 @@ class ReaderActivity : BaseActivity() {
         }
     }
 }
+
+/**
+ * Returns true when the device is in tabletop posture.
+ *
+ * Tabletop posture requires a horizontal, half-open fold that occludes the
+ * middle of the window fully.
+ */
+internal fun isInTabletopPosture(foldState: ReaderFoldState?): Boolean {
+    return foldState != null &&
+        foldState.orientation == FoldOrientation.Horizontal &&
+        foldState.state == FoldState.HalfOpen &&
+        foldState.occlusionType == FoldOcclusionType.Full
+}
+
+/**
+ * Computes the viewer height in pixels for the tabletop upper region.
+ *
+ * Returns null when the device is not in tabletop posture, so the caller uses
+ * MATCH_PARENT. In tabletop posture it returns the height above the fold,
+ * reduced by [statusBarInset] because the fold bounds live in window pixels.
+ * The result never goes below zero.
+ */
+internal fun tabletopViewerHeight(
+    foldState: ReaderFoldState?,
+    statusBarInset: Int,
+): Int? {
+    if (foldState == null || !isInTabletopPosture(foldState)) return null
+    return (foldState.bounds.top - statusBarInset).coerceAtLeast(0)
+}

app/src/test/java/eu/kanade/tachiyomi/ui/reader/ReaderViewerConstraintTest.kt

@@ -0,0 +1,71 @@
+package eu.kanade.tachiyomi.ui.reader
+
+import eu.kanade.presentation.util.FoldBounds
+import eu.kanade.presentation.util.FoldOcclusionType
+import eu.kanade.presentation.util.FoldOrientation
+import eu.kanade.presentation.util.FoldState
+import eu.kanade.presentation.util.ReaderFoldState
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class ReaderViewerConstraintTest {
+
+    @Test
+    fun `is in tabletop posture when horizontal half-open fully occluding`() {
+        isInTabletopPosture(tabletopFold()) shouldBe true
+    }
+
+    @Test
+    fun `is not in tabletop posture when the fold is vertical`() {
+        val fold = tabletopFold().copy(orientation = FoldOrientation.Vertical)
+
+        isInTabletopPosture(fold) shouldBe false
+    }
+
+    @Test
+    fun `is not in tabletop posture when the device is flat`() {
+        val fold = tabletopFold().copy(state = FoldState.Flat)
+
+        isInTabletopPosture(fold) shouldBe false
+    }
+
+    @Test
+    fun `is not in tabletop posture when the fold does not occlude`() {
+        val fold = tabletopFold().copy(occlusionType = FoldOcclusionType.None)
+
+        isInTabletopPosture(fold) shouldBe false
+    }
+
+    @Test
+    fun `is not in tabletop posture when there is no fold`() {
+        isInTabletopPosture(null) shouldBe false
+    }
+
+    @Test
+    fun `heights to the upper region above the fold minus the status bar`() {
+        val fold = tabletopFold(top = 720)
+
+        tabletopViewerHeight(fold, statusBarInset = 120) shouldBe 600
+    }
+
+    @Test
+    fun `returns null when not in tabletop posture`() {
+        tabletopViewerHeight(tabletopFold().copy(state = FoldState.Flat), statusBarInset = 120)
+            .shouldBeNull()
+    }
+
+    @Test
+    fun `coerces a negative height to zero when the status bar is larger than the fold`() {
+        val fold = tabletopFold(top = 50)
+
+        tabletopViewerHeight(fold, statusBarInset = 120) shouldBe 0
+    }
+
+    private fun tabletopFold(top: Int = 720): ReaderFoldState = ReaderFoldState(
+        orientation = FoldOrientation.Horizontal,
+        state = FoldState.HalfOpen,
+        occlusionType = FoldOcclusionType.Full,
+        bounds = FoldBounds(left = 0, top = top, right = 1440, bottom = top + 10),
+    )
+}