Merge branch 'detect-system-setting-changes' into 'master'

detect system auto rotate setting changes

See merge request videostreaming/grayjay!62

app/src/main/java/com/futo/platformplayer/Settings.kt

@@ -415,8 +415,8 @@ class Settings : FragmentedStorageFileJson() {
         @FormField(R.string.simplify_sources, FieldForm.TOGGLE, R.string.simplify_sources_description, 4)
         var simplifySources: Boolean = true;
 
-        @FormField(R.string.force_enable_auto_rotate_in_full_screen, FieldForm.TOGGLE, R.string.force_enable_auto_rotate_in_full_screen_description, 5)
-        var forceAllowFullScreenRotation: Boolean = false
+        @FormField(R.string.always_allow_reverse_landscape_auto_rotate, FieldForm.TOGGLE, R.string.always_allow_reverse_landscape_auto_rotate_description, 5)
+        var alwaysAllowReverseLandscapeAutoRotate: Boolean = true
 
         @FormField(R.string.background_behavior, FieldForm.DROPDOWN, -1, 6)
         @DropdownFieldOptionsId(R.array.player_background_behavior)

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/VideoDetailFragment.kt

@@ -1,10 +1,14 @@
 package com.futo.platformplayer.fragment.mainactivity.main
 
+import android.annotation.SuppressLint
 import android.content.Context
 import android.content.pm.ActivityInfo
 import android.content.res.Configuration
+import android.database.ContentObserver
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.view.LayoutInflater
 import android.view.OrientationEventListener
 import android.view.View
@@ -84,8 +88,7 @@ class VideoDetailFragment() : MainFragment() {
 
     private var _landscapeOrientationListener: LandscapeOrientationListener? = null
     private var _portraitOrientationListener: PortraitOrientationListener? = null
-    private var _lastSetOrientation: Int = Configuration.ORIENTATION_UNDEFINED
-    private var _ignoreNextNewOrientation = false
+    private var _autoRotateObserver: AutoRotateObserver? = null
 
     fun nextVideo() {
         _viewDetail?.nextVideo(true, true, true);
@@ -102,22 +105,19 @@ class VideoDetailFragment() : MainFragment() {
         ) < resources.getInteger(R.integer.column_width_dp) * 2
     }
 
+    private fun isAutoRotateEnabled(): Boolean {
+        return android.provider.Settings.System.getInt(
+            context?.contentResolver,
+            android.provider.Settings.System.ACCELEROMETER_ROTATION, 0
+        ) == 1
+    }
+
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
 
         val isLandscapeVideo: Boolean = _viewDetail?.isLandscapeVideo() ?: false
-
         val isSmallWindow = isSmallWindow()
 
-        val temp = _lastSetOrientation
-
-        if (_ignoreNextNewOrientation) {
-            _ignoreNextNewOrientation = false
-        } else {
-            // the device has rotated so update our state tracking what the physical orientation of the device is
-            _lastSetOrientation = newConfig.orientation
-        }
-
         if (
             isSmallWindow
             && newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE
@@ -130,7 +130,6 @@ class VideoDetailFragment() : MainFragment() {
             && isFullscreen
             && !Settings.instance.playback.fullscreenPortrait
             && newConfig.orientation == Configuration.ORIENTATION_PORTRAIT
-            && temp == Configuration.ORIENTATION_LANDSCAPE
             && isLandscapeVideo
         ) {
             _viewDetail?.setFullscreen(false)
@@ -166,25 +165,16 @@ class VideoDetailFragment() : MainFragment() {
         val isFullScreenPortraitAllowed = Settings.instance.playback.fullscreenPortrait
         val isReversePortraitAllowed = Settings.instance.playback.reversePortrait
         val rotationLock = StatePlayer.instance.rotationLock
+        val alwaysAllowReverseLandscapeAutoRotate = Settings.instance.playback.alwaysAllowReverseLandscapeAutoRotate
 
         val isLandscapeVideo: Boolean = _viewDetail?.isLandscapeVideo() ?: false
 
         val isSmallWindow = isSmallWindow()
-
-        val autoRotateEnabled = android.provider.Settings.System.getInt(
-            context?.contentResolver,
-            android.provider.Settings.System.ACCELEROMETER_ROTATION, 0
-        ) == 1
+        val autoRotateEnabled = isAutoRotateEnabled()
 
         // For small windows if the device isn't landscape right now and full screen portrait isn't allowed then we should force landscape
-        if (isSmallWindow && isFullscreen && !isFullScreenPortraitAllowed && _lastSetOrientation != Configuration.ORIENTATION_LANDSCAPE && !rotationLock && isLandscapeVideo) {
-            if (Settings.instance.playback.forceAllowFullScreenRotation) {
-                a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
-            } else {
-                a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
-            }
-            // the next orientation change will not reflect the device because we are manually setting the orientation to landscape
-            _ignoreNextNewOrientation = true
+        if (isSmallWindow && isFullscreen && !isFullScreenPortraitAllowed && resources.configuration.orientation == Configuration.ORIENTATION_PORTRAIT && !rotationLock && isLandscapeVideo) {
+            a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
             if (autoRotateEnabled
             ) {
                 // start listening for the device to rotate to landscape
@@ -192,19 +182,21 @@ class VideoDetailFragment() : MainFragment() {
                 _landscapeOrientationListener?.enableListener()
             }
         }
+        // For small windows if always all reverse landscape then we'll lock the orientation to landscape when system auto-rotate is off to make sure that locking
+        // and unlockiung in the player settings keep orientation in landscape
+        else if (isSmallWindow && isFullscreen && !isFullScreenPortraitAllowed && alwaysAllowReverseLandscapeAutoRotate && !rotationLock && isLandscapeVideo && !autoRotateEnabled) {
+            a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+        }
         // For small windows if the device isn't in a portrait orientation and we're in the maximized state then we should force portrait
-        else if (isSmallWindow && !isMinimizingFromFullScreen && !isFullscreen && state == State.MAXIMIZED && _lastSetOrientation == Configuration.ORIENTATION_LANDSCAPE) {
+        // only do this if auto-rotate is on portrait is forced when leaving full screen for autorotate off
+        else if (isSmallWindow && !isMinimizingFromFullScreen && !isFullscreen && state == State.MAXIMIZED && resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+            @SuppressLint("SourceLockedOrientationActivity")
             a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
-            // the next orientation change will not reflect the device because we are manually setting the orientation to portrait
-            _ignoreNextNewOrientation = true
             if (autoRotateEnabled
             ) {
                 // start listening for the device to rotate to portrait
                 // at which point we'll be able to set requestedOrientation to back to UNSPECIFIED
                 _portraitOrientationListener?.enableListener()
-            } else {
-                // the rotation state resets to portrait when changing requestedOrientation
-                _lastSetOrientation = Configuration.ORIENTATION_PORTRAIT
             }
         } else if (rotationLock) {
             _portraitOrientationListener?.disableListener()
@@ -388,12 +380,13 @@ class VideoDetailFragment() : MainFragment() {
             updateOrientation()
         }
 
+        val delayBeforeRemoveRotationLock = 800L
+
         _landscapeOrientationListener = LandscapeOrientationListener(requireContext())
         {
             CoroutineScope(Dispatchers.Main).launch {
                 // delay to make sure that the system auto rotate updates
-                delay(300)
-                _lastSetOrientation = Configuration.ORIENTATION_LANDSCAPE
+                delay(delayBeforeRemoveRotationLock)
                 updateOrientation()
             }
         }
@@ -401,11 +394,14 @@ class VideoDetailFragment() : MainFragment() {
         {
             CoroutineScope(Dispatchers.Main).launch {
                 // delay to make sure that the system auto rotate updates
-                delay(300)
-                _lastSetOrientation = Configuration.ORIENTATION_PORTRAIT
+                delay(delayBeforeRemoveRotationLock)
                 updateOrientation()
             }
         }
+        _autoRotateObserver = AutoRotateObserver(requireContext(), Handler(Looper.getMainLooper())) {
+            updateOrientation()
+        }
+        _autoRotateObserver?.startObserving()
 
         return _view!!;
     }
@@ -510,6 +506,7 @@ class VideoDetailFragment() : MainFragment() {
 
         _landscapeOrientationListener?.disableListener()
         _portraitOrientationListener?.disableListener()
+        _autoRotateObserver?.stopObserving()
 
         _viewDetail?.let {
             _viewDetail = null;
@@ -582,6 +579,11 @@ class VideoDetailFragment() : MainFragment() {
             showSystemUI()
         }
 
+        // temporarily force the device to portrait if auto-rotate is disabled to prevent landscape when exiting full screen on a small device
+//        @SuppressLint("SourceLockedOrientationActivity")
+//        if (!isFullscreen && isSmallWindow() && !isAutoRotateEnabled() && !isMinimizingFromFullScreen) {
+//            activity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+//        }
         updateOrientation();
         _view?.allowMotion = !fullscreen;
     }
@@ -666,3 +668,25 @@ class PortraitOrientationListener(
         }
     }
 }
+
+class AutoRotateObserver(context: Context, handler: Handler, private val onAutoRotateChanged: () -> Unit) : ContentObserver(handler) {
+    private val contentResolver = context.contentResolver
+
+    override fun onChange(selfChange: Boolean) {
+        super.onChange(selfChange)
+
+        onAutoRotateChanged()
+    }
+
+    fun startObserving() {
+        contentResolver.registerContentObserver(
+            android.provider.Settings.System.getUriFor(android.provider.Settings.System.ACCELEROMETER_ROTATION),
+            false,
+            this
+        )
+    }
+
+    fun stopObserving() {
+        contentResolver.unregisterContentObserver(this)
+    }
+}

app/src/main/res/values/strings.xml

@@ -287,8 +287,8 @@
     <string name="planned_content_notifications_description">Schedules discovered planned content as notifications, resulting in more accurate notifications for this content.</string>
     <string name="attempt_to_utilize_byte_ranges">Attempt to utilize byte ranges</string>
     <string name="auto_update">Auto Update</string>
-    <string name="force_enable_auto_rotate_in_full_screen">Force Enable Auto-Rotate In Full-Screen Mode</string>
-    <string name="force_enable_auto_rotate_in_full_screen_description">Force enable auto-rotation between the two landscape orientations in full-screen mode, even when you disable auto-rotate at the system level.</string>
+    <string name="always_allow_reverse_landscape_auto_rotate">Always allow reverse landscape auto-rotate</string>
+    <string name="always_allow_reverse_landscape_auto_rotate_description">There will always be auto-rotation between the two landscape orientations in full-screen mode, even when you disable auto-rotate in system settings.</string>
     <string name="simplify_sources">Simplify sources</string>
     <string name="simplify_sources_description">Deduplicate sources by resolution so that only more relevant sources are visible.</string>
     <string name="automatic_backup">Automatic Backup</string>