feat: battery optimization prompt for bulk downloads (R539) (#566)

* feat(539): BatteryOptimizationPromptRequest signal class — all tests passing (autoloop iter 1)

* feat(539): BatteryOptimizationChecker utility — all tests passing (autoloop iter 2)

* R539: Fix battery optimization flow emissions in tests

Resolved timing issue where test emissions weren't reaching collectors due to
dispatcher mismatch. The manager's scope was using Dispatchers.IO which the
test's runTest couldn't control.

Changes:
- Added scopeForTesting parameter to AnimeDownloadManager allowing test
  environment to inject test's CoroutineScope
- Manager now uses test scope when provided, otherwise uses production scope
  with SupervisorJob + Dispatchers.IO
- Updated checkBatteryOptimization() to use scope.launch() for emissions,
  which now runs on the test dispatcher in tests
- Updated all 5 battery prompt tests to pass test scope via constructor
- Added advanceUntilIdle() calls to ensure flow emissions complete before
  assertions run

All 5 tests now pass:
✓ flow emits when 10+ items queued with optimization enabled
✓ flow does not emit when optimization disabled
✓ flow does not emit when prompt already shown
✓ flow does not emit when fewer than 10 items
✓ flow emits at most once even with multiple rapid calls

This fixes the root cause by making the manager testable via dependency
injection of the coroutine scope, rather than attempting workarounds with
tryEmit() or arbitrary delays.

* R539: Implement battery optimization prompts for MangaDownloadManager

- Add BatteryOptimizationChecker dependency injection to MangaDownloadManager
- Add batteryOptimizationPromptFlow for UI signal emissions
- Implement checkBatteryOptimization() to emit signals when 10+ chapters queued
- Add scope testability via downloaderForTesting and scopeForTesting parameters
- Create MangaDownloadManagerBatteryPromptTest with 5 test scenarios
- All 10 battery prompt tests passing (5 anime + 5 manga)

* R539: Integrate battery optimization dialog into MainActivity

Completes R539 battery optimization prompt feature:

## Changes
- Created BatteryOptimizationDialog Composable: Shows when user queues 10+ downloads with battery optimization enabled
  - Displays title, description, and action buttons (Cancel, Open Settings)
  - Opens device battery optimization settings via Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
  - Handles API level differences: Android S+ uses app-specific action, earlier versions use general battery settings
  - Includes fallback to battery saver settings if device doesn't support the primary intent

- Integrated battery optimization observers into MainActivity
  - Injected AnimeDownloadManager and MangaDownloadManager
  - Added LaunchedEffect blocks collecting from batteryOptimizationPromptFlow
  - Displays dialog separately for anime/manga downloads using state management

- Added localized string resources:
  - battery_optimization_title: "Battery Optimization Enabled"
  - battery_optimization_description: Explains impact on bulk downloads
  - battery_optimization_settings: "Open Settings" button text

## Testing
- All 10 battery optimization prompt tests pass (5 anime + 5 manga):
  - Emission with 10+ items and optimization enabled
  - No emission with <10 items
  - No emission when optimization disabled
  - No emission when prompt already shown
  - Emission at most once with multiple rapid calls

- No regressions in existing tests

## Architecture Notes
- Dialog follows existing pattern in MainActivity (similar to changelog dialog)
- String keys use existing keys (action_cancel) where available
- Respects owned coroutine scope pattern (viewModelScope in DownloadManager)

* chore(539): fix ktlint max-line-length in battery prompt test files

* docs(539): update changelog (autoloop)

* style(r539): spotless import reorder in MangaDownloadManager

---------

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

Author: ryacub

CHANGELOG.md

@@ -14,14 +14,17 @@ The format is a modified version of [Keep a Changelog](https://keepachangelog.co
 
 ### Added
 
+- **Custom accent color theme** — Material 3 app-wide theming from a user-selected accent seed; generates light/dark color schemes with Android 14 contrast-awareness and readability guardrails (contrast clamp + fallback)
 - **Download crash notification** — notifies the user when the anime or manga download job crashes repeatedly (threshold: 3 consecutive crashes), with a tap-to-open link to the download manager
 - **LightNovelPluginManager unit tests** — 37 tests covering install flow, manifest validation, update policy, APK download/checksum verification, install launch, in-flight mutex deduplication, error recovery, and orphaned APK cleanup
 - **Persist dialog/form state across rotation** — PIN setup, PIN change (step/value/error), and enrichment chooser source selection now survive configuration changes via `rememberSaveable`
 - **PIN error feedback** — shows an error message when saving a new PIN fails (e.g., storage write error), instead of silently closing the dialog
 - **Download queue** — migrated anime and manga download queue screens from RecyclerView/FlexibleAdapter to Jetpack Compose; supports drag-to-reorder sources, per-item progress display, and move-to-top/bottom actions; removes flexibleadapter dependency
+- **Battery optimization prompt** — shows a one-time dialog when queuing 10 or more downloads while the app is subject to battery optimization; offers direct navigation to system settings to exempt the app
 
 ### Fixed
 
+- Browse tab reselect now opens anime or manga global search based on the current Browse context instead of always defaulting to anime search
 - Coroutine cancellation no longer surfaces as a user-visible error in Discover and entry enrichment screens
 - One-off UI events in Migrate and PlayerSettingsCustomButton screens no longer drop on delivery when the UI collector is temporarily inactive during lifecycle transitions; channels switched to buffered
 - Migrate rayniyomi-specific screen state collection to `collectAsStateWithLifecycle()` — stops background Flow collection when UI is STOPPED
@@ -49,6 +52,9 @@ The format is a modified version of [Keep a Changelog](https://keepachangelog.co
 - Firebase BOM → 34.10.0; migrate analytics and crashlytics from deprecated `-ktx` modules to base modules
 - Test/tooling upgrade: JUnit Jupiter → 6.0.3, Kotest → 6.1.7, MockK → 1.14.9, unifile snapshot update
 - Align Firebase config comments in `build.gradle.kts` with actual runtime configuration
+- Custom theme mode foundation: added `ThemeMode.CUSTOM` and `AppTheme.CUSTOM` enum values wired with safe fallback to system behavior; no UI exposure yet
+- Pin real SHA-256 certificate fingerprint (`f3565300…`) for LightNovel plugin trust verification; removes placeholder fingerprints
+- Remove unused `CoroutineScope` parameter from `PlayerMpvInitializer` constructor
 - Remove dead `rollbackToLastGood()` stub and `ROLLBACK_NOT_AVAILABLE` error code from `LightNovelPluginManager`; converted 4 deferred TODO comments to tracked GitHub issues (#536–#539)
 
 ## [0.18.1.75] - 2026-03-13

app/src/main/java/eu/kanade/presentation/components/BatteryOptimizationDialog.kt

@@ -0,0 +1,72 @@
+package eu.kanade.presentation.components
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.provider.Settings
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+
+/**
+ * Dialog shown when the user queues 10+ items for download and the app is subject
+ * to battery optimization. Prompts user to exempt the app from battery optimization.
+ */
+@Composable
+fun BatteryOptimizationDialog(
+    onDismiss: () -> Unit,
+) {
+    val context = LocalContext.current
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = {
+            Text(text = stringResource(MR.strings.battery_optimization_title))
+        },
+        text = {
+            Text(text = stringResource(MR.strings.battery_optimization_description))
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(text = stringResource(MR.strings.action_cancel))
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = {
+                openBatteryOptimizationSettings(context)
+                onDismiss()
+            }) {
+                Text(text = stringResource(MR.strings.battery_optimization_settings))
+            }
+        },
+    )
+}
+
+/**
+ * Opens the battery optimization settings for the app.
+ */
+fun openBatteryOptimizationSettings(context: Context) {
+    val packageName = context.packageName
+    val intent = when {
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+                data = android.net.Uri.parse("package:$packageName")
+            }
+        }
+
+        else -> {
+            Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS)
+        }
+    }
+
+    try {
+        context.startActivity(intent)
+    } catch (e: Exception) {
+        // Fallback to general battery settings if specific intent fails
+        context.startActivity(Intent(Settings.ACTION_BATTERY_SAVER_SETTINGS))
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/download/anime/AnimeDownloadManager.kt

@@ -6,6 +6,8 @@ import androidx.annotation.VisibleForTesting
 import eu.kanade.tachiyomi.animesource.AnimeSource
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.data.download.anime.model.AnimeDownload
+import eu.kanade.tachiyomi.data.download.core.BatteryOptimizationChecker
+import eu.kanade.tachiyomi.data.download.core.BatteryOptimizationPromptRequest
 import eu.kanade.tachiyomi.data.download.core.DownloadQueueMutations
 import eu.kanade.tachiyomi.data.download.model.DownloadDisplayStatus
 import eu.kanade.tachiyomi.util.size
@@ -15,6 +17,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.emitAll
@@ -53,9 +57,18 @@ class AnimeDownloadManager(
     private val getCategories: GetAnimeCategories = Injekt.get(),
     private val sourceManager: AnimeSourceManager = Injekt.get(),
     private val downloadPreferences: DownloadPreferences = Injekt.get(),
+    private val batteryOptimizationChecker: BatteryOptimizationChecker = BatteryOptimizationChecker(
+        context,
+        context.getSystemService(Context.POWER_SERVICE) as? PowerManager,
+    ),
+    private val downloaderForTesting: AnimeDownloader? = null,
+    private val scopeForTesting: CoroutineScope? = null,
 ) {
 
-    private val downloader: AnimeDownloader by lazy { AnimeDownloader(context, provider, cache, sourceManager) }
+    private val downloader: AnimeDownloader by lazy {
+        downloaderForTesting
+            ?: AnimeDownloader(context, provider, cache, sourceManager)
+    }
     private val pendingDeleter: AnimeDownloadPendingDeleter by lazy { AnimeDownloadPendingDeleter(context) }
 
     @VisibleForTesting
@@ -69,7 +82,20 @@ class AnimeDownloadManager(
         logcat(LogPriority.ERROR, throwable) { "Unhandled exception in AnimeDownloadManager scope" }
     }
 
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO + exceptionHandler)
+    private val scope = scopeForTesting ?: CoroutineScope(SupervisorJob() + Dispatchers.IO + exceptionHandler)
+
+    /**
+     * SharedFlow that emits battery optimization prompt requests when 10+ items
+     * are queued and battery optimization is enabled.
+     */
+    private val _batteryOptimizationPromptFlow =
+        MutableSharedFlow<BatteryOptimizationPromptRequest>(extraBufferCapacity = 1)
+
+    /**
+     * Public flow for battery optimization prompt requests.
+     */
+    val batteryOptimizationPromptFlow: SharedFlow<BatteryOptimizationPromptRequest> =
+        _batteryOptimizationPromptFlow
 
     /**
      * Cancels the manager-owned coroutine scope, stopping all background operations.
@@ -517,16 +543,26 @@ class AnimeDownloadManager(
     /**
      * Checks if battery optimization is disabled and logs a warning if not.
      * Called when user queues 10+ items for download.
+     * Emits a BatteryOptimizationPromptRequest if optimization is enabled.
      */
     private fun checkBatteryOptimization() {
-        val powerManager = context.getSystemService(Context.POWER_SERVICE) as? PowerManager
-        val isIgnoringBatteryOptimizations = powerManager?.isIgnoringBatteryOptimizations(context.packageName) ?: true
-
-        if (!isIgnoringBatteryOptimizations) {
+        if (batteryOptimizationChecker.isOptimizationEnabled()) {
             logcat(LogPriority.WARN) {
                 "Battery optimization is enabled - bulk downloads may be interrupted. " +
                     "Consider exempting app from battery optimization."
             }
+
+            // Emit the battery optimization prompt signal
+            // Launch on the scope's context (Dispatchers.IO in production, test dispatcher in tests)
+            scope.launch {
+                try {
+                    _batteryOptimizationPromptFlow.emit(BatteryOptimizationPromptRequest())
+                } catch (e: Exception) {
+                    logcat(LogPriority.ERROR, e) {
+                        "Failed to emit battery optimization prompt"
+                    }
+                }
+            }
         }
 
         // Mark as shown so we don't prompt again

app/src/main/java/eu/kanade/tachiyomi/data/download/core/BatteryOptimizationChecker.kt

@@ -0,0 +1,14 @@
+package eu.kanade.tachiyomi.data.download.core
+
+import android.content.Context
+import android.os.PowerManager
+
+class BatteryOptimizationChecker(
+    private val context: Context,
+    private val powerManager: PowerManager?,
+) {
+    fun isOptimizationEnabled(): Boolean {
+        if (powerManager == null) return true
+        return !powerManager.isIgnoringBatteryOptimizations(context.packageName)
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/download/core/BatteryOptimizationPromptRequest.kt

@@ -0,0 +1,9 @@
+package eu.kanade.tachiyomi.data.download.core
+
+class BatteryOptimizationPromptRequest {
+    override fun equals(other: Any?) = other is BatteryOptimizationPromptRequest
+
+    override fun hashCode() = this::class.hashCode()
+
+    override fun toString() = "BatteryOptimizationPromptRequest()"
+}

app/src/main/java/eu/kanade/tachiyomi/data/download/manga/MangaDownloadManager.kt

@@ -3,16 +3,22 @@ package eu.kanade.tachiyomi.data.download.manga
 import android.content.Context
 import android.os.PowerManager
 import androidx.annotation.VisibleForTesting
+import eu.kanade.tachiyomi.data.download.core.BatteryOptimizationChecker
+import eu.kanade.tachiyomi.data.download.core.BatteryOptimizationPromptRequest
 import eu.kanade.tachiyomi.data.download.core.DownloadQueueMutations
 import eu.kanade.tachiyomi.data.download.manga.model.MangaDownload
 import eu.kanade.tachiyomi.data.download.model.DownloadDisplayStatus
 import eu.kanade.tachiyomi.source.MangaSource
 import eu.kanade.tachiyomi.source.model.Page
 import eu.kanade.tachiyomi.util.size
+import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.emitAll
@@ -53,9 +59,17 @@ class MangaDownloadManager(
     private val getCategories: GetMangaCategories = Injekt.get(),
     private val sourceManager: MangaSourceManager = Injekt.get(),
     private val downloadPreferences: DownloadPreferences = Injekt.get(),
+    private val batteryOptimizationChecker: BatteryOptimizationChecker = BatteryOptimizationChecker(
+        context,
+        context.getSystemService(Context.POWER_SERVICE) as? PowerManager,
+    ),
+    private val downloaderForTesting: MangaDownloader? = null,
+    private val scopeForTesting: CoroutineScope? = null,
 ) {
 
-    private val downloader: MangaDownloader by lazy { MangaDownloader(context, provider, cache) }
+    private val downloader: MangaDownloader by lazy {
+        downloaderForTesting ?: MangaDownloader(context, provider, cache)
+    }
     private val pendingDeleter: MangaDownloadPendingDeleter by lazy { MangaDownloadPendingDeleter(context) }
 
     @VisibleForTesting
@@ -65,7 +79,32 @@ class MangaDownloadManager(
      * Manager-owned coroutine scope for background operations.
      * Uses SupervisorJob to prevent child failures from cancelling other operations.
      */
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
+        logcat(LogPriority.ERROR, throwable) { "Unhandled exception in MangaDownloadManager scope" }
+    }
+
+    private val scope = scopeForTesting ?: CoroutineScope(SupervisorJob() + Dispatchers.IO + exceptionHandler)
+
+    /**
+     * SharedFlow that emits battery optimization prompt requests when 10+ items
+     * are queued and battery optimization is enabled.
+     */
+    private val _batteryOptimizationPromptFlow =
+        MutableSharedFlow<BatteryOptimizationPromptRequest>(extraBufferCapacity = 1)
+
+    /**
+     * Public flow for battery optimization prompt requests.
+     */
+    val batteryOptimizationPromptFlow: SharedFlow<BatteryOptimizationPromptRequest> =
+        _batteryOptimizationPromptFlow
+
+    /**
+     * Cancels the manager-owned coroutine scope, stopping all background operations.
+     * Should be called when the manager is no longer needed.
+     */
+    fun close() {
+        scope.cancel()
+    }
 
     /**
      * Mutex to synchronize download queue manipulation operations.
@@ -506,17 +545,23 @@ class MangaDownloadManager(
      * Called when user queues 10+ items for download.
      */
     private fun checkBatteryOptimization() {
-        val powerManager = context.getSystemService(Context.POWER_SERVICE) as? PowerManager
-        val isIgnoringBatteryOptimizations = powerManager?.isIgnoringBatteryOptimizations(context.packageName) ?: true
-
-        if (!isIgnoringBatteryOptimizations) {
+        if (batteryOptimizationChecker.isOptimizationEnabled()) {
             logcat(LogPriority.WARN) {
                 "Battery optimization is enabled - bulk downloads may be interrupted. " +
                     "Consider exempting app from battery optimization."
             }
+
+            scope.launch {
+                try {
+                    _batteryOptimizationPromptFlow.emit(BatteryOptimizationPromptRequest())
+                } catch (e: Exception) {
+                    logcat(LogPriority.ERROR, e) {
+                        "Failed to emit battery optimization prompt"
+                    }
+                }
+            }
         }
 
-        // Mark as shown so we don't prompt again
         downloadPreferences.batteryOptimizationPromptShown().set(true)
     }
 }

app/src/main/java/eu/kanade/tachiyomi/ui/main/MainActivity.kt

@@ -61,6 +61,7 @@ import eu.kanade.domain.base.BasePreferences
 import eu.kanade.domain.source.anime.interactor.GetAnimeIncognitoState
 import eu.kanade.domain.source.manga.interactor.GetMangaIncognitoState
 import eu.kanade.presentation.components.AppStateBanners
+import eu.kanade.presentation.components.BatteryOptimizationDialog
 import eu.kanade.presentation.components.DownloadedOnlyBannerBackgroundColor
 import eu.kanade.presentation.components.IncognitoModeBannerBackgroundColor
 import eu.kanade.presentation.components.IndexingBannerBackgroundColor
@@ -75,7 +76,9 @@ import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.core.common.Constants
 import eu.kanade.tachiyomi.data.cache.ChapterCache
 import eu.kanade.tachiyomi.data.download.anime.AnimeDownloadCache
+import eu.kanade.tachiyomi.data.download.anime.AnimeDownloadManager
 import eu.kanade.tachiyomi.data.download.manga.MangaDownloadCache
+import eu.kanade.tachiyomi.data.download.manga.MangaDownloadManager
 import eu.kanade.tachiyomi.data.notification.NotificationReceiver
 import eu.kanade.tachiyomi.data.updater.AppUpdateChecker
 import eu.kanade.tachiyomi.data.updater.RELEASE_URL
@@ -130,6 +133,9 @@ class MainActivity : BaseActivity() {
     private val downloadCache: MangaDownloadCache by injectLazy()
     private val chapterCache: ChapterCache by injectLazy()
 
+    private val animeDownloadManager: AnimeDownloadManager by injectLazy()
+    private val mangaDownloadManager: MangaDownloadManager by injectLazy()
+
     private val getAnimeIncognitoState: GetAnimeIncognitoState by injectLazy()
     private val getMangaIncognitoState: GetMangaIncognitoState by injectLazy()
 
@@ -338,6 +344,34 @@ class MainActivity : BaseActivity() {
                     },
                 )
             }
+
+            // Battery optimization prompt from anime downloads
+            var showBatteryOptimizationAnimeDlg by remember { mutableStateOf(false) }
+            LaunchedEffect(Unit) {
+                animeDownloadManager.batteryOptimizationPromptFlow
+                    .collectLatest {
+                        showBatteryOptimizationAnimeDlg = true
+                    }
+            }
+            if (showBatteryOptimizationAnimeDlg) {
+                BatteryOptimizationDialog(
+                    onDismiss = { showBatteryOptimizationAnimeDlg = false },
+                )
+            }
+
+            // Battery optimization prompt from manga downloads
+            var showBatteryOptimizationMangaDlg by remember { mutableStateOf(false) }
+            LaunchedEffect(Unit) {
+                mangaDownloadManager.batteryOptimizationPromptFlow
+                    .collectLatest {
+                        showBatteryOptimizationMangaDlg = true
+                    }
+            }
+            if (showBatteryOptimizationMangaDlg) {
+                BatteryOptimizationDialog(
+                    onDismiss = { showBatteryOptimizationMangaDlg = false },
+                )
+            }
         }
 
         val startTime = System.currentTimeMillis()