fix(audio-bible): restore audio bar + toolbar indicator on activity reattach and return-from-background (#219)

* fix(audio-bible): restore audio bar + toolbar indicator on activity reattach and return-from-background

The audio service survives activity recreation and backgrounding, but the
audio bar reset to hidden on the recreated/returning activity, so a playing
session lost its UI surface (Issue 5: rotation hid the bar; Issue 6: return
from background lost the bar + verse marker while audio kept playing).

IsiActivity.onStart now calls AudioBarController.reshowIfSessionActive(),
which binds to the service only when it reports an active session
(BibleAudioService.hasActiveSession) and re-shows the bar once the first
active PlaybackState arrives — re-synced via the existing StateFlow
collection, no flicker, no service spin-up for users who never started audio.
The toolbar menuAudio active icon follows the restored bar visibility. The
service stays the source of truth; no onSaveInstanceState added.

* refactor(audio-bible): consolidate pending-reshow handling into a single one-shot branch

Author: yukuku

Alkitab/src/main/java/yuku/alkitab/base/IsiActivity.kt

@@ -1144,6 +1144,11 @@ class IsiActivity : BaseLeftDrawerActivity(), LeftDrawer.Text.Listener, VerseAct
         // Re-resolve the audio overlay color in case the user changed the
         // reading theme via the textAppearancePanel while we were stopped.
         audioHighlightColorCached = 0
+
+        // Restore the audio bar + toolbar indicator if the service kept playing
+        // across recreation (rotation) or while we were backgrounded. Covers
+        // both a freshly recreated activity and a return on the same instance.
+        audioBinder.reshowIfSessionActive()
     }
 
     override fun onDestroy() {

Alkitab/src/main/java/yuku/alkitab/base/audio/AudioBarController.kt

@@ -109,6 +109,15 @@ class AudioBarController(
     private var bound = false
     /** Tracks whether the user has *requested* the bar visible (via [toggle]). */
     private var requestedVisible = false
+    /**
+     * Set by [reshowIfSessionActive] while we are binding to an
+     * already-running service purely to restore the bar after activity
+     * recreation / return-from-background. The first projected
+     * [PlaybackState] that reports [PlaybackState.isActive] flips the bar back
+     * on, then clears this flag. Cleared without showing if the session has
+     * ended by the time we connect (no flicker).
+     */
+    private var reshowPending = false
     /**
      * Set while the user has the slider thumb under their finger. Drives a
      * special-case in [projectToUi]: live playback continues to push a
@@ -211,6 +220,23 @@ class AudioBarController(
         this.composeView = composeView
     }
 
+    /**
+     * Restores the audio bar when the activity becomes visible again (rotation,
+     * process/activity recreation, or return-from-background) while the service
+     * is still mid-session. Call from `IsiActivity.onStart` — it covers both a
+     * fresh activity (after [attach]) and a returning one on the same instance.
+     *
+     * Binds only when [BibleAudioService.hasActiveSession] is already true, so
+     * we never spin the service up for users who haven't started audio. The
+     * actual reshow happens in [projectToUi] once the first [PlaybackState]
+     * arrives, avoiding a show-then-hide flicker if the session just ended.
+     */
+    fun reshowIfSessionActive() {
+        if (!shouldBindForReshow(requestedVisible, BibleAudioService.hasActiveSession)) return
+        reshowPending = true
+        ensureBound()
+    }
+
     private var composeContentInstalled = false
 
     private fun ensureComposeContent() {
@@ -357,6 +383,7 @@ class AudioBarController(
 
     fun hide() {
         requestedVisible = false
+        reshowPending = false
         dragging = false
         selectedSource = null
         startVerse1 = 0
@@ -390,6 +417,7 @@ class AudioBarController(
      * may continue playing when the activity is recreated (M4 lock-screen).
      */
     fun detach() {
+        reshowPending = false
         if (bound) {
             try {
                 context.unbindService(serviceConnection)
@@ -523,6 +551,29 @@ class AudioBarController(
 
     private fun projectToUi(state: PlaybackState) {
         val host = this.host
+
+        // Auto-reshow after activity recreation / return-from-background: the
+        // service is still mid-session but the bar was reset to hidden. Flip it
+        // back on once the first active state lands, reconstructing the session
+        // source from the service's loaded versionId. Done before the
+        // _uiState.update below so `visible` picks it up in the same emission.
+        if (reshowPending) {
+            val reshow = shouldReshowNow(reshowPending, state)
+            // One-shot: consume the flag on the first state after binding,
+            // whether or not we actually reshow. If the session ended before we
+            // connected (!state.isActive) we just drop it — no show-then-hide
+            // flicker against an idle service.
+            reshowPending = false
+            if (reshow) {
+                requestedVisible = true
+                ensureComposeContent()
+                host?.audioAvailableSources()
+                    ?.firstOrNull { it.versionId == state.versionId }
+                    ?.let { selectedSource = it }
+                host?.audioBarVisibilityChanged(true)
+            }
+        }
+
         // Snapshot before we drain — if a load was queued before the service
         // connected, the first incoming state is usually `IDLE`, which would
         // briefly clear the spinner before our loadChapter call sets it back
@@ -597,5 +648,20 @@ class AudioBarController(
 
     companion object {
         private const val TAG = "AudioBarController"
+
+        /**
+         * Whether [reshowIfSessionActive] should bind to the service: only when
+         * the bar isn't already managed by this controller ([requestedVisible])
+         * and the service reports an active session. Pure for unit testing.
+         */
+        internal fun shouldBindForReshow(requestedVisible: Boolean, hasActiveSession: Boolean): Boolean =
+            !requestedVisible && hasActiveSession
+
+        /**
+         * Whether a pending reshow should fire for [state]: only once the first
+         * active state arrives. Pure for unit testing.
+         */
+        internal fun shouldReshowNow(reshowPending: Boolean, state: PlaybackState): Boolean =
+            reshowPending && state.isActive
     }
 }

Alkitab/src/main/java/yuku/alkitab/base/audio/BibleAudioService.kt

@@ -90,6 +90,18 @@ class BibleAudioService : MediaSessionService() {
         private const val DEFAULT_PLAYBACK_SPEED = 1.0f
 
         private const val TAG = "BibleAudioService"
+
+        /**
+         * Process-wide flag (the service is local and single-instance) that lets
+         * [AudioBarController] decide whether to re-show the audio bar after the
+         * activity is recreated or returns from the background — *without*
+         * binding (which would spin the service up via `BIND_AUTO_CREATE` for
+         * users who never started audio). Set true while a chapter is loaded,
+         * cleared on stop / destroy.
+         */
+        @Volatile
+        var hasActiveSession: Boolean = false
+            private set
     }
 
     /** Parameters for [loadChapter]. The display fields drive the lock-screen metadata. */
@@ -304,6 +316,7 @@ class BibleAudioService : MediaSessionService() {
     }
 
     override fun onDestroy() {
+        hasActiveSession = false
         positionJob?.cancel()
         loadJob?.cancel()
         timingJob?.cancel()
@@ -326,6 +339,7 @@ class BibleAudioService : MediaSessionService() {
         loadJob?.cancel()
         timingJob?.cancel()
         currentRequest = request
+        hasActiveSession = true
         pendingStartVerse1 = request.startVerse_1
         playerReadyForSeek = false
         timingLoaded = false
@@ -487,6 +501,7 @@ class BibleAudioService : MediaSessionService() {
         timingJob?.cancel()
         positionJob?.cancel()
         currentRequest = null
+        hasActiveSession = false
         player.pause()
         _playbackState.value = PlaybackState.IDLE
         stopSelf()

Alkitab/src/main/java/yuku/alkitab/base/audio/PlaybackState.kt

@@ -39,6 +39,16 @@ data class PlaybackState(
     val speed: Float,
     val error: String?,
 ) {
+    /**
+     * True while a chapter is loaded into the service (playing, paused, or
+     * buffering) — i.e. not [IDLE]/stopped. Drives the auto-reshow decision in
+     * [AudioBarController] when the activity is recreated or returns from the
+     * background. Mirrors the `bookId >= 0` invariant that `loadChapter` sets
+     * and `stop()` clears.
+     */
+    val isActive: Boolean
+        get() = bookId >= 0
+
     companion object {
         val IDLE = PlaybackState(
             isPlaying = false,

Alkitab/src/test/java/yuku/alkitab/base/audio/AudioBarControllerReshowTest.kt

@@ -0,0 +1,53 @@
+package yuku.alkitab.base.audio
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Pure-logic tests for the audio-bar auto-reshow decision used after the
+ * activity is recreated (rotation) or returns from the background while the
+ * [BibleAudioService] keeps playing. See [AudioBarController.reshowIfSessionActive].
+ */
+class AudioBarControllerReshowTest {
+
+    private fun state(bookId: Int): PlaybackState =
+        PlaybackState.IDLE.copy(bookId = bookId, chapter_1 = 1, versionId = "preset/in-tb")
+
+    @Test
+    fun `reshow binds when the service is mid-session and the bar is not already managed`() {
+        assertTrue(AudioBarController.shouldBindForReshow(requestedVisible = false, hasActiveSession = true))
+    }
+
+    @Test
+    fun `reshow does not bind when the service is idle`() {
+        assertFalse(AudioBarController.shouldBindForReshow(requestedVisible = false, hasActiveSession = false))
+    }
+
+    @Test
+    fun `reshow does not bind when the bar is already shown by this controller`() {
+        assertFalse(AudioBarController.shouldBindForReshow(requestedVisible = true, hasActiveSession = true))
+    }
+
+    @Test
+    fun `pending reshow fires once an active state arrives`() {
+        assertTrue(AudioBarController.shouldReshowNow(reshowPending = true, state = state(bookId = 5)))
+    }
+
+    @Test
+    fun `pending reshow stays hidden against an idle state to avoid show-then-hide flicker`() {
+        assertFalse(AudioBarController.shouldReshowNow(reshowPending = true, state = state(bookId = -1)))
+    }
+
+    @Test
+    fun `no reshow when none is pending even if the state is active`() {
+        assertFalse(AudioBarController.shouldReshowNow(reshowPending = false, state = state(bookId = 5)))
+    }
+
+    @Test
+    fun `PlaybackState reports active once a chapter is loaded and idle otherwise`() {
+        assertFalse(PlaybackState.IDLE.isActive)
+        assertTrue(state(bookId = 0).isActive)
+        assertTrue(state(bookId = 41).isActive)
+    }
+}