Better playback lifecycle handling (#191)

Refactors lifecycle event observers

When the app is "paused", aka not actively focused, but still visible
(such as when opening Android TV OS menu), playback will pause.

When the app is "stopped", aka not visible (such as pressing Home
button), playback will stop, report playback progress, and return to the
previous screen.

I think this will fix #181, but I don't have a controller to test with

app/src/main/java/com/github/damontecres/wholphin/util/PlaybackLifecycleObserver.kt

@@ -0,0 +1,46 @@
+package com.github.damontecres.wholphin.util
+
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import com.github.damontecres.wholphin.ui.nav.Destination
+import com.github.damontecres.wholphin.ui.nav.NavigationManager
+import dagger.hilt.android.scopes.ActivityRetainedScoped
+import javax.inject.Inject
+
+/**
+ * Observes the activity lifecycle in order to pause/resume/stop playback
+ */
+@ActivityRetainedScoped
+class PlaybackLifecycleObserver
+    @Inject
+    constructor(
+        private val navigationManager: NavigationManager,
+        private val playerFactory: PlayerFactory,
+    ) : DefaultLifecycleObserver {
+        private var wasPlaying: Boolean? = null
+
+        override fun onStart(owner: LifecycleOwner) {
+            wasPlaying = null
+        }
+
+        override fun onResume(owner: LifecycleOwner) {
+            if (wasPlaying == true) {
+                playerFactory.currentPlayer?.let {
+                    if (!it.isReleased) it.play()
+                }
+            }
+        }
+
+        override fun onPause(owner: LifecycleOwner) {
+            playerFactory.currentPlayer?.let {
+                wasPlaying = it.isPlaying
+                it.pause()
+            }
+        }
+
+        override fun onStop(owner: LifecycleOwner) {
+            if (navigationManager.backStack.lastOrNull() is Destination.Playback) {
+                navigationManager.goBack()
+            }
+        }
+    }

app/src/main/java/com/github/damontecres/wholphin/util/PlayerFactory.kt

@@ -0,0 +1,72 @@
+@file:OptIn(markerClass = [UnstableApi::class])
+
+package com.github.damontecres.wholphin.util
+
+import android.content.Context
+import androidx.annotation.OptIn
+import androidx.datastore.core.DataStore
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.ExoPlayer
+import com.github.damontecres.wholphin.preferences.AppPreferences
+import com.github.damontecres.wholphin.preferences.MediaExtensionStatus
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.runBlocking
+import timber.log.Timber
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Constructs a [Player] instance for video playback
+ */
+@Singleton
+class PlayerFactory
+    @Inject
+    constructor(
+        @param:ApplicationContext private val context: Context,
+        private val appPreferences: DataStore<AppPreferences>,
+    ) {
+        @Volatile
+        var currentPlayer: Player? = null
+            private set
+
+        fun createVideoPlayer(): Player {
+            if (currentPlayer?.isReleased == true) {
+                throw IllegalStateException("Player was not released before trying to create a new one!")
+            }
+
+            val extensions =
+                runBlocking { appPreferences.data.firstOrNull() }?.playbackPreferences?.overrides?.mediaExtensionsEnabled
+            Timber.v("extensions=$extensions")
+            val rendererMode =
+                when (extensions) {
+                    MediaExtensionStatus.MES_FALLBACK -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
+                    MediaExtensionStatus.MES_PREFERRED -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER
+                    MediaExtensionStatus.MES_DISABLED -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_OFF
+                    else -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
+                }
+            val newPlayer =
+                ExoPlayer
+                    .Builder(context)
+                    .setRenderersFactory(
+                        DefaultRenderersFactory(context)
+                            .setEnableDecoderFallback(true)
+                            .setExtensionRendererMode(rendererMode),
+                    ).build()
+                    .apply {
+                        playWhenReady = true
+                    }
+            currentPlayer = newPlayer
+            return newPlayer
+        }
+    }
+
+val Player.isReleased: Boolean
+    get() {
+        return when (this) {
+            is ExoPlayer -> isReleased
+            else -> throw IllegalStateException("Unknown Player type: ${this::class.qualifiedName}")
+        }
+    }

app/src/main/java/com/github/damontecres/wholphin/util/TrackActivityPlaybackListener.kt

@@ -76,13 +76,13 @@ class TrackActivityPlaybackListener(
     fun release() {
         task.cancel()
         TIMER.purge()
-        val position = player.currentPosition.milliseconds.inWholeTicks
+        val position = player.currentPosition.milliseconds
         coroutineScope.launch(Dispatchers.IO + ExceptionHandler()) {
-            Timber.v("reportPlaybackStopped for ${itemPlayback.itemId}")
+            Timber.v("reportPlaybackStopped for ${itemPlayback.itemId} at $position")
             api.playStateApi.reportPlaybackStopped(
                 PlaybackStopInfo(
                     itemId = itemPlayback.itemId,
-                    positionTicks = position,
+                    positionTicks = position.inWholeTicks,
                     failed = false,
                     playSessionId = playback.playSessionId,
                     liveStreamId = playback.liveStreamId,