Windows ga (#358)

* Enhance Cloud TTS with navigation controls and shared UI overlay in desktop app

* Refactor Cloud TTS voice settings and remove standalone settings overlay on desktop app

* Persist reader window state and improve slider interaction in desktop app

* Improve PDF page transitions and refine focus management in desktop app

* Refactor scrollbar interaction and adjust desktop modal focus handling

* Improve PDF sidecar synchronization and cross-platform metadata compatibility

* Refactor PDF annotation comment logic to shared module and implement Desktop UI

* Refactor reader screen to use tap-to-toggle and full-width styling in desktop app

* Refactor reader workspace layout and chrome-panel interactions

* Implement global search keyboard shortcuts and focusable chrome layers

* Implement flavor-specific legal links and update the About UI

* Refactor reader UI controls on desktop app

* Enhance desktop folder sync with background metadata extraction and improved error handling

* Refactor Library UI and remove redundant Home tab in desktop app

* Add custom tooltips to reader icon buttons in desktop app

* Integrate app theme controls into reader interfaces on desktop

* Add right-to-left pagination support and improve focus restoration on desktop app

* Improve EPUB pagination geometry and diagnostic logging for layout cutoffs on desktop app

* Update desktop reader defaults and implement settings migration

* Implement block-based position tracking in ReaderLocator

* Enhance EPUB highlighting reliability in desktop app

* Add support for custom reader themes and update highlight palette logic in desktop app

* Replace the Tools panel with a "More" dropdown menu and refactor account UI

* Implement account profile header in desktop sidebar

* Implement cloud sync reliability improvements and sidebar toggle on desktop app

* Improve EPUB annotation synchronization and highlight mapping accuracy in desktop app

* Integrate WebView2 for EPUB vertical rendering on Windows

* Refactor reader layout logic and enhance WebView2 diagnostics

* Improve vertical reading layout and WebView2 resizing on Desktop

* Refine vertical reading mode layout and margin handling

* Enhance reader locator precision and Desktop mode-switching reliability

* Implement chapter-level caching and warm-start pagination in desktop app

* Replace bundled KCEF with native system webviews via SWT

* Refactor EPUB page info bar visibility and layout logic

* Improve PDF toolbar persistence and fix tab reactivation logic

* Enable multi-selection and bulk operations for custom fonts

* Refactor instrumentation tests

* Add EPUB UI test fixture and initial instrumentation tests

* Expand EpubReader UI tests and improve accessibility

* Add instrumentation tests and test tags for library and reader screens

* Enhance OPDS parser logic and catalog integration

* Add support for toggling local synchronization on a per-folder basis.

* Implement tri-state sizing for the TTS overlay

* Persist TTS overlay size across sessions

* Refactor reader brightness control and add incremental step buttons

* Improve CSS support, pagination control, and style-aware semantic caching

* Improve link handling, interaction, and diagnostics in the paginated reader

* crash fixes

* Implement persistent pending removal for external files

* Implement book-specific word replacements

* Add native vertical reading mode with custom renderer

* Implement text selection and navigation improvements for the native vertical reader

* Implement locator-based navigation and improved vertical scrolling in native vertical mode in epub

* Implement lazy loading and chapter prefetching for native vertical reader

* Improve window lifecycle and disposal handling on Desktop

* Optimize vertical reading performance in desktop app

* Enhance TTS start accuracy and diagnostic logging on desktop

* Refactor AI settings visibility on desktop

* Improve pagination height measurement and enhance cutoff diagnostics

* Implement lifecycle management and improve justified text splitting for pagination

* Refine AI usage tracking and force AI feature visibility on Desktop

* Add descriptive context comments and usage examples to string and plural resources.

* Optimize performance and memory usage in search and state mapping

* Replace reader page sliders with minimal slider and navigation controls

* Add support for CBT comic archives

* Harden file path validation and XML parsing to prevent security vulnerabilities

* Implement local account profile caching and optimize desktop performance

* Improve desktop persistence reliability and add Linux secure storage support

* Improved PDF zoom stability and layout prediction during zoom commits

* Improved PDF spread layout prediction, reader focus restoration, and account profile caching

* Enhance highlight precision and scoping using block-local offsets and CFIs

* Enhance cloud book content synchronization and background downloads

* Implement granular timestamp tracking for reading positions and PDF annotations

* Restrict diagnostic logging and stack traces to debug builds

* Refine PDF page gaps and reader chrome interaction logic

* Refactor PDF highlight rendering and overhaul Desktop sidebar UI

* Implement a new interaction dock and undo/redo history for PDF annotations in desktop

* Enhance PDF color picker and improve navigation scroll restoration

* Add highlight palette customization and improve selection menu UI in desktop app epub reader

* Enhance desktop shelf management and library organization

app/src/androidTest/java/com/aryan/reader/AppNavigationTest.kt

@@ -1,146 +1,117 @@
-// AppNavigationTest.kt
 package com.aryan.reader
 
-import android.net.Uri
-import androidx.compose.material3.windowsizeclass.ExperimentalMaterial3WindowSizeClassApi
-import androidx.compose.material3.windowsizeclass.WindowSizeClass
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.test.junit4.createComposeRule
-import androidx.compose.ui.unit.DpSize
-import androidx.compose.ui.unit.dp
-import androidx.navigation.compose.ComposeNavigator
-import androidx.navigation.testing.TestNavHostController
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.aryan.reader.epub.EpubBook
-import kotlinx.coroutines.flow.MutableStateFlow
-import org.junit.Assert.assertEquals
-import org.junit.Before
-import org.junit.Rule
+import com.aryan.reader.shared.FileType
+import com.aryan.reader.shared.ReaderFeatureSurface
+import com.aryan.reader.shared.ReaderPlatform
+import com.aryan.reader.shared.SharedFileCapabilities
+import com.google.common.truth.Truth.assertThat
 import org.junit.Test
 import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
 class AppNavigationTest {
 
-    @get:Rule
-    val composeTestRule = createComposeRule()
+    @Test
+    fun appDestinations_useStableReaderRoutes() {
+        assertThat(AppDestinations.MAIN_ROUTE).isEqualTo("main")
+        assertThat(AppDestinations.PDF_VIEWER_ROUTE).isEqualTo("pdf_viewer")
+        assertThat(AppDestinations.EPUB_READER_ROUTE).isEqualTo("epub_reader")
+    }
 
-    private lateinit var navController: TestNavHostController
-    private val fakeUiState = MutableStateFlow(ReaderScreenState())
+    @Test
+    fun androidReaderSurface_mapsPdfBackedTypesToPdfViewer() {
+        val mappedSurfaces = listOf(
+            FileType.PDF,
+            FileType.CBZ,
+            FileType.CBR,
+            FileType.CB7,
+            FileType.CBT,
+            FileType.PPTX
+        ).associateWith { it.readerSurfaceOnAndroid() }
 
-    // Mock ViewModel that uses the fake state
-    private val fakeViewModel: MainViewModel = object : MainViewModel(
-        ApplicationProvider.getApplicationContext()
-    ) {
-        override val uiState = fakeUiState
-        override fun clearSelectedFile() {
-            fakeUiState.value = fakeUiState.value.copy(
-                selectedFileType = null,
-                selectedPdfUri = null,
-                selectedEpubBook = null
+        assertThat(mappedSurfaces).containsExactly(
+            FileType.PDF, ReaderFeatureSurface.PDF_VIEWER,
+            FileType.CBZ, ReaderFeatureSurface.PDF_VIEWER,
+            FileType.CBR, ReaderFeatureSurface.PDF_VIEWER,
+            FileType.CB7, ReaderFeatureSurface.PDF_VIEWER,
+            FileType.CBT, ReaderFeatureSurface.PDF_VIEWER,
+            FileType.PPTX, ReaderFeatureSurface.PDF_VIEWER
+        )
+    }
+
+    @Test
+    fun androidReaderSurface_mapsTextBackedTypesToEpubReader() {
+        val mappedSurfaces = listOf(
+            FileType.EPUB,
+            FileType.MOBI,
+            FileType.MD,
+            FileType.TXT,
+            FileType.HTML,
+            FileType.FB2,
+            FileType.DOCX,
+            FileType.ODT,
+            FileType.FODT
+        ).associateWith { it.readerSurfaceOnAndroid() }
+
+        assertThat(mappedSurfaces).containsExactly(
+            FileType.EPUB, ReaderFeatureSurface.EPUB_READER,
+            FileType.MOBI, ReaderFeatureSurface.EPUB_READER,
+            FileType.MD, ReaderFeatureSurface.EPUB_READER,
+            FileType.TXT, ReaderFeatureSurface.EPUB_READER,
+            FileType.HTML, ReaderFeatureSurface.EPUB_READER,
+            FileType.FB2, ReaderFeatureSurface.EPUB_READER,
+            FileType.DOCX, ReaderFeatureSurface.EPUB_READER,
+            FileType.ODT, ReaderFeatureSurface.EPUB_READER,
+            FileType.FODT, ReaderFeatureSurface.EPUB_READER
+        )
+    }
+
+    @Test
+    fun androidReaderSurface_returnsNullForUnknownFileType() {
+        assertThat(FileType.UNKNOWN.readerSurfaceOnAndroid()).isNull()
+    }
+
+    @Test
+    fun appNavBackInterceptor_onlyHandlesResumedNonReaderBackStackEntries() {
+        assertThat(
+            shouldInterceptAppNavBack(
+                currentRoute = AppDestinations.PRO_SCREEN_ROUTE,
+                hasPreviousBackStackEntry = true,
+                isCurrentEntryResumed = true
             )
-        }
-    }
-
-    @OptIn(ExperimentalMaterial3WindowSizeClassApi::class)
-    @Before
-    fun setup() {
-        composeTestRule.setContent {
-            navController = TestNavHostController(LocalContext.current)
-            navController.navigatorProvider.addNavigator(ComposeNavigator())
-            AppNavigation(
-                navController = navController,
-                windowSizeClass = WindowSizeClass.calculateFromSize(DpSize(400.dp, 800.dp)),
-                viewModel = fakeViewModel
+        ).isTrue()
+        assertThat(
+            shouldInterceptAppNavBack(
+                currentRoute = AppDestinations.MAIN_ROUTE,
+                hasPreviousBackStackEntry = true,
+                isCurrentEntryResumed = true
             )
-        }
-    }
-
-    @Test
-    fun appNavigation_defaultStartDestination_isMainRoute() {
-        val currentRoute = navController.currentBackStackEntry?.destination?.route
-        assertEquals(AppDestinations.MAIN_ROUTE, currentRoute)
-    }
-
-    @Test
-    fun appNavigation_whenPdfSelected_navigatesToPdfViewer() {
-        // Trigger state change
-        fakeUiState.value = ReaderScreenState(
-            selectedFileType = FileType.PDF,
-            selectedPdfUri = Uri.parse("content://dummy.pdf")
-        )
-
-        // Let compose recompose and run LaunchedEffect
-        composeTestRule.waitForIdle()
-
-        val currentRoute = navController.currentBackStackEntry?.destination?.route
-        assertEquals(AppDestinations.PDF_VIEWER_ROUTE, currentRoute)
-    }
-
-    @Test
-    fun appNavigation_whenPptxSelected_navigatesToPdfViewer() {
-        fakeUiState.value = ReaderScreenState(
-            selectedFileType = FileType.PPTX,
-            selectedPdfUri = Uri.parse("content://dummy.pptx")
-        )
-
-        composeTestRule.waitForIdle()
-
-        val currentRoute = navController.currentBackStackEntry?.destination?.route
-        assertEquals(AppDestinations.PDF_VIEWER_ROUTE, currentRoute)
-    }
-
-    @Test
-    fun appNavigation_whenEpubSelected_navigatesToEpubReader() {
-        // Trigger state change
-        fakeUiState.value = ReaderScreenState(
-            selectedFileType = FileType.EPUB,
-            selectedEpubBook = EpubBook(
-                fileName = "dummy.epub",
-                title = "Dummy Book",
-                author = "Author",
-                language = "en",
-                coverImage = null
+        ).isFalse()
+        assertThat(
+            shouldInterceptAppNavBack(
+                currentRoute = AppDestinations.PDF_VIEWER_ROUTE,
+                hasPreviousBackStackEntry = true,
+                isCurrentEntryResumed = true
             )
-        )
-
-        composeTestRule.waitForIdle()
-
-        val currentRoute = navController.currentBackStackEntry?.destination?.route
-        assertEquals(AppDestinations.EPUB_READER_ROUTE, currentRoute)
+        ).isFalse()
+        assertThat(
+            shouldInterceptAppNavBack(
+                currentRoute = AppDestinations.PRO_SCREEN_ROUTE,
+                hasPreviousBackStackEntry = false,
+                isCurrentEntryResumed = true
+            )
+        ).isFalse()
+        assertThat(
+            shouldInterceptAppNavBack(
+                currentRoute = AppDestinations.PRO_SCREEN_ROUTE,
+                hasPreviousBackStackEntry = true,
+                isCurrentEntryResumed = false
+            )
+        ).isFalse()
     }
 
-    @Test
-    fun appNavigation_whenFileCleared_navigatesBackToMain() {
-        // First, navigate to PDF viewer
-        fakeUiState.value = ReaderScreenState(
-            selectedFileType = FileType.PDF,
-            selectedPdfUri = Uri.parse("content://dummy.pdf")
-        )
-        composeTestRule.waitForIdle()
-        assertEquals(AppDestinations.PDF_VIEWER_ROUTE, navController.currentBackStackEntry?.destination?.route)
-
-        // Then, trigger the clear action (simulating onNavigateBack)
-        fakeViewModel.clearSelectedFile()
-        composeTestRule.waitForIdle()
-
-        val currentRoute = navController.currentBackStackEntry?.destination?.route
-        assertEquals(AppDestinations.MAIN_ROUTE, currentRoute)
-    }
-
-    @Test
-    fun appNavigation_whenUnknownFileTypeSelected_navigatesBackToMain() {
-        fakeUiState.value = ReaderScreenState(
-            selectedFileType = FileType.PDF,
-            selectedPdfUri = Uri.parse("content://dummy.pdf")
-        )
-        composeTestRule.waitForIdle()
-        assertEquals(AppDestinations.PDF_VIEWER_ROUTE, navController.currentBackStackEntry?.destination?.route)
-
-        fakeUiState.value = ReaderScreenState(selectedFileType = FileType.UNKNOWN)
-        composeTestRule.waitForIdle()
-
-        assertEquals(AppDestinations.MAIN_ROUTE, navController.currentBackStackEntry?.destination?.route)
+    private fun FileType.readerSurfaceOnAndroid(): ReaderFeatureSurface? {
+        return SharedFileCapabilities.surfaceFor(this, ReaderPlatform.ANDROID)
     }
 }