resources: improved method that saves the current state (fixes #4080)

app/src/main/java/org/ole/planet/myplanet/ui/viewer/VideoPlayerActivity.kt

@@ -1,11 +1,18 @@
 package org.ole.planet.myplanet.ui.viewer
 
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
 import android.content.SharedPreferences
+import android.media.AudioManager
 import android.net.Uri
 import android.os.Bundle
 import androidx.activity.OnBackPressedCallback
 import androidx.annotation.OptIn
 import androidx.appcompat.app.AppCompatActivity
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
 import androidx.media3.common.MediaItem
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.datasource.DataSource
@@ -29,6 +36,17 @@ class VideoPlayerActivity : AppCompatActivity(), AuthSessionUpdater.AuthCallback
     private var auth: String = ""
     private var videoURL: String = ""
     private lateinit var settings: SharedPreferences
+    private var playWhenReady = true
+    private var currentPosition = 0L
+    private var isActivityVisible = false
+
+    private val audioBecomingNoisyReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent?.action == AudioManager.ACTION_AUDIO_BECOMING_NOISY) {
+                exoPlayer?.pause()
+            }
+        }
+    }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -41,6 +59,8 @@ class VideoPlayerActivity : AppCompatActivity(), AuthSessionUpdater.AuthCallback
         videoURL = extras?.getString("videoURL") ?: ""
         auth = extras?.getString("Auth") ?: ""
 
+        registerAudioNoisyReceiver()
+
         when (videoType) {
             "offline" -> prepareExoPlayerFromFileUri(videoURL)
             "online" -> AuthSessionUpdater(this, settings)
@@ -65,10 +85,71 @@ class VideoPlayerActivity : AppCompatActivity(), AuthSessionUpdater.AuthCallback
         runOnUiThread { Utilities.toast(this, getString(R.string.connection_failed_reason) + s) }
     }
 
+    override fun onStart() {
+        super.onStart()
+        isActivityVisible = true
+    }
+
+    override fun onResume() {
+        super.onResume()
+        isActivityVisible = true
+        if (exoPlayer == null) {
+            when {
+                videoURL.startsWith("http") -> streamVideoFromUrl(videoURL, auth)
+                else -> prepareExoPlayerFromFileUri(videoURL)
+            }
+        }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        isActivityVisible = false
+        pauseAndReleasePlayer()
+    }
+
+    override fun onStop() {
+        super.onStop()
+        isActivityVisible = false
+        pauseAndReleasePlayer()
+    }
+
+    private fun pauseAndReleasePlayer() {
+        exoPlayer?.pause()
+        releasePlayer()
+    }
+
+    private fun releasePlayer() {
+        exoPlayer?.let { player ->
+            try {
+                playWhenReady = player.playWhenReady
+                currentPosition = player.currentPosition
+                player.stop()
+                player.clearMediaItems()
+                player.release()
+            } catch (e: Exception) {
+                e.printStackTrace()
+            } finally {
+                exoPlayer = null
+            }
+        }
+    }
+
     @OptIn(UnstableApi::class)
     private fun streamVideoFromUrl(videoUrl: String, auth: String) {
+        if (!isActivityVisible) return
+
         val trackSelectorDef = DefaultTrackSelector(this)
-        exoPlayer = ExoPlayer.Builder(this).setTrackSelector(trackSelectorDef).build()
+
+        exoPlayer = ExoPlayer.Builder(this)
+            .setTrackSelector(trackSelectorDef)
+            .setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(C.USAGE_MEDIA)
+                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
+                    .build(),
+                true
+            )
+            .build()
 
         val videoUri = Uri.parse(videoUrl)
         val requestProperties = hashMapOf("Cookie" to auth)
@@ -81,61 +162,67 @@ class VideoPlayerActivity : AppCompatActivity(), AuthSessionUpdater.AuthCallback
             .createMediaSource(MediaItem.fromUri(videoUri))
 
         binding.exoPlayerSimple.player = exoPlayer
-        exoPlayer?.setMediaSource(mediaSource)
-        exoPlayer?.prepare()
-        exoPlayer?.playWhenReady = true
+        exoPlayer?.apply {
+            setMediaSource(mediaSource)
+            seekTo(currentPosition)
+            playWhenReady = [email protected]
+            prepare()
+        }
     }
 
     @OptIn(UnstableApi::class)
     private fun prepareExoPlayerFromFileUri(uriString: String) {
+        if (!isActivityVisible) return
+
         val uri = Uri.parse(uriString)
+        val trackSelectorDef = DefaultTrackSelector(this)
+
         exoPlayer = ExoPlayer.Builder(this)
-            .setTrackSelector(DefaultTrackSelector(this))
+            .setTrackSelector(trackSelectorDef)
             .setLoadControl(DefaultLoadControl())
+            .setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(C.USAGE_MEDIA)
+                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
+                    .build(),
+                true
+            )
             .build()
 
         val dataSpec = DataSpec(uri)
         val fileDataSource = FileDataSource()
         try {
             fileDataSource.open(dataSpec)
+            val factory = DataSource.Factory { fileDataSource }
+
+            fileDataSource.uri?.let { uri ->
+                val audioSource = ProgressiveMediaSource.Factory(factory)
+                    .createMediaSource(MediaItem.fromUri(uri))
+
+                binding.exoPlayerSimple.player = exoPlayer
+                exoPlayer?.apply {
+                    setMediaSource(audioSource)
+                    seekTo(currentPosition)
+                    playWhenReady = [email protected]
+                    prepare()
+                }
+            }
         } catch (e: FileDataSource.FileDataSourceException) {
             e.printStackTrace()
         }
-
-        val factory = DataSource.Factory { fileDataSource }
-        val audioSource: MediaSource?
-        if (fileDataSource.uri != null) {
-            audioSource = ProgressiveMediaSource.Factory(factory)
-                .createMediaSource(MediaItem.fromUri(fileDataSource.uri!!))
-            binding.exoPlayerSimple.player = exoPlayer
-            exoPlayer?.setMediaSource(audioSource)
-            exoPlayer?.prepare()
-            exoPlayer?.playWhenReady = true
-        }
-    }
-
-    override fun onResume() {
-        super.onResume()
-        exoPlayer?.playWhenReady = true
     }
 
-    override fun onPause() {
-        super.onPause()
-        exoPlayer?.playWhenReady = false
-    }
-
-    override fun onStop() {
-        super.onStop()
-        releasePlayer()
+    private fun registerAudioNoisyReceiver() {
+        val filter = IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY)
+        registerReceiver(audioBecomingNoisyReceiver, filter)
     }
 
     override fun onDestroy() {
         super.onDestroy()
-        releasePlayer()
-    }
-
-    private fun releasePlayer() {
-        exoPlayer?.release()
-        exoPlayer = null
+        try {
+            unregisterReceiver(audioBecomingNoisyReceiver)
+        } catch (e: IllegalArgumentException) {
+            e.printStackTrace()
+        }
     }
 }