feat(core): add a new rotation provider: from display listener

Author: ThibaultBee

README.md

@@ -290,13 +290,22 @@ streamer.targetRotation =
     Surface.ROTATION_90 // Or Surface.ROTATION_0, Surface.ROTATION_180, Surface.ROTATION_270
 ```
 
-StreamPack comes with a `RotationProvider` that fetches and listens the device rotation: the
-`DeviceRotationProvider`. The `DeviceRotationProvider` is backed by the `OrientationEventListener`.
+StreamPack comes with 2 `RotationProvider` that fetches and listens the device rotation:
+
+- the `SensorRotationProvider`. The `SensorRotationProvider` is backed by the
+  `OrientationEventListener`
+  and it follows the device orientation.
+- the `DisplayRotationProvider`. The `DisplayRotationProvider` is backed by the `DisplayManager` and
+  if orientation is locked, it will return the last known orientation.
+
+You can transform the `RotationProvider` into a `Flow` provider through the `asFlowProvider`
+extension.
 
 ```kotlin
 // Already instantiated streamer
 val streamer = DefaultCameraStreamer(context = requireContext())
 
+// For callback based
 val listener = object : IRotationProvider.Listener {
     override fun onOrientationChanged(rotation: Int) {
         streamer.targetRotation = rotation
@@ -306,12 +315,18 @@ rotationProvider.addListener(listener)
 
 // Don't forget to remove the listener when you don't need it anymore
 rotationProvider.removeListener(listener)
+
+// For coroutine based
+val rotationFlowProvider = rotationProvider.asFlowProvider()
+// Then in a coroutine suspend function
+rotationFlowProvider.rotationFlow.collect { it ->
+    streamer.targetRotation = it
+}
 ```
 
 See the `demos/camera` for a complete example.
 
-To only get the device supported orientations, you can use the `DisplayManager.DisplayListener` or
-create your own `targetRotation` provider.
+You can also create your own `targetRotation` provider.
 
 ## Tips
 

core/src/main/java/io/github/thibaultbee/streampack/core/streamers/orientation/DisplayRotationProvider.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2024 Thibault B.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.github.thibaultbee.streampack.core.streamers.orientation
+
+import android.content.Context
+import android.hardware.display.DisplayManager
+import io.github.thibaultbee.streampack.core.internal.utils.extensions.displayRotation
+
+/**
+ * A [RotationProvider] that provides display rotation.
+ * It uses [DisplayManager] to get display rotation.
+ * It follows the orientation of the display only. If device or application are locked in a specific
+ * orientation, it will not change.
+ *
+ * It will notify listeners when the display orientation changes.
+ *
+ * @param context The application context
+ */
+class DisplayRotationProvider(val context: Context) : RotationProvider() {
+    private val lock = Any()
+    private val displayManager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+    private var _rotation = context.displayRotation
+
+    private val displayListener = object : DisplayManager.DisplayListener {
+        override fun onDisplayAdded(displayId: Int) = Unit
+        override fun onDisplayRemoved(displayId: Int) = Unit
+        override fun onDisplayChanged(displayId: Int) {
+            val newRotation = context.displayRotation
+
+            if (_rotation != newRotation) {
+                _rotation = newRotation
+
+                synchronized(lock) {
+                    listeners.forEach { it.onOrientationChanged(newRotation) }
+                }
+            }
+        }
+    }
+
+    override val rotation: Int
+        get() = _rotation
+
+    override fun addListener(listener: IRotationProvider.Listener) {
+        synchronized(lock) {
+            val mustRegister = listeners.isEmpty()
+            super.addListener(listener)
+            if (mustRegister) {
+                displayManager.registerDisplayListener(displayListener, null)
+            }
+        }
+    }
+
+    override fun removeListener(listener: IRotationProvider.Listener) {
+        synchronized(lock) {
+            super.removeListener(listener)
+            if (listeners.isEmpty()) {
+                displayManager.unregisterDisplayListener(displayListener)
+            }
+        }
+    }
+}

core/src/main/java/io/github/thibaultbee/streampack/core/streamers/orientation/RotationFlowProvider.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 Thibault B.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.github.thibaultbee.streampack.core.streamers.orientation
+
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+
+
+/**
+ * A [RotationProvider] that provides device rotation as a [Flow] instead of a callback.
+ *
+ * @param rotationProvider The rotation provider to get rotation from
+ */
+internal class RotationFlowProvider(private val rotationProvider: RotationProvider) :
+    IRotationFlowProvider {
+    override val rotationFlow: Flow<Int> = callbackFlow {
+        val listener = object : IRotationProvider.Listener {
+            override fun onOrientationChanged(rotation: Int) {
+                trySend(rotation)
+            }
+        }
+        rotationProvider.addListener(listener)
+        awaitClose { rotationProvider.removeListener(listener) }
+    }
+}

core/src/main/java/io/github/thibaultbee/streampack/core/streamers/orientation/RotationProvider.kt

@@ -3,6 +3,7 @@ package io.github.thibaultbee.streampack.core.streamers.orientation
 import androidx.annotation.IntRange
 import io.github.thibaultbee.streampack.core.internal.utils.RotationValue
 import io.github.thibaultbee.streampack.core.internal.utils.extensions.rotationToDegrees
+import kotlinx.coroutines.flow.Flow
 
 val IRotationProvider.rotationDegrees: Int
     @IntRange(from = 0, to = 359)
@@ -36,4 +37,14 @@ abstract class RotationProvider : IRotationProvider {
     override fun removeListener(listener: IRotationProvider.Listener) {
         listeners.remove(listener)
     }
+}
+
+fun RotationProvider.asFlowProvider(): IRotationFlowProvider = RotationFlowProvider(this)
+
+interface IRotationFlowProvider {
+    /**
+     * The rotation in one the [Surface] rotations from the device natural orientation.
+     */
+    @get:RotationValue
+    val rotationFlow: Flow<Int>
 }

…rs/orientation/DeviceRotationProvider.kt …rs/orientation/SensorRotationProvider.ktcore/src/main/java/io/github/thibaultbee/streampack/core/streamers/orientation/DeviceRotationProvider.kt renamed to core/src/main/java/io/github/thibaultbee/streampack/core/streamers/orientation/SensorRotationProvider.kt core/src/main/java/io/github/thibaultbee/streampack/core/streamers/orientation/DeviceRotationProvider.kt renamed to core/src/main/java/io/github/thibaultbee/streampack/core/streamers/orientation/SensorRotationProvider.kt

@@ -22,7 +22,16 @@ import io.github.thibaultbee.streampack.core.internal.utils.extensions.displayRo
 import io.github.thibaultbee.streampack.core.utils.extensions.clamp90
 
 
-class DeviceRotationProvider(val context: Context) : RotationProvider() {
+/**
+ * A [RotationProvider] that provides device rotation.
+ * It uses [OrientationEventListener] to get device orientation.
+ * It follows the orientation of the sensor, so it will change when the device is rotated.
+ *
+ * It will notify listeners when the device orientation changes.
+ *
+ * @param context The application context
+ */
+class SensorRotationProvider(val context: Context) : RotationProvider() {
     private val lock = Any()
     private var _rotation = context.displayRotation
 
@@ -69,7 +78,7 @@ class DeviceRotationProvider(val context: Context) : RotationProvider() {
         /**
          * Converts orientation degrees to [Surface] rotation.
          */
-        fun orientationToSurfaceRotation(rotationDegrees: Int): Int {
+        private fun orientationToSurfaceRotation(rotationDegrees: Int): Int {
             return if (rotationDegrees >= 315 || rotationDegrees < 45) {
                 Surface.ROTATION_0
             } else if (rotationDegrees >= 225) {

demos/camera/src/main/java/io/github/thibaultbee/streampack/app/data/rotation/RotationRepository.kt

@@ -1,11 +1,9 @@
 package io.github.thibaultbee.streampack.app.data.rotation
 
 import android.content.Context
-import io.github.thibaultbee.streampack.core.streamers.orientation.DeviceRotationProvider
-import io.github.thibaultbee.streampack.core.streamers.orientation.IRotationProvider
-import kotlinx.coroutines.channels.awaitClose
+import io.github.thibaultbee.streampack.core.streamers.orientation.SensorRotationProvider
+import io.github.thibaultbee.streampack.core.streamers.orientation.asFlowProvider
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
 
 
 /**
@@ -14,16 +12,14 @@ import kotlinx.coroutines.flow.callbackFlow
 class RotationRepository(
     context: Context,
 ) {
-    private val rotationProvider = DeviceRotationProvider(context)
-    val rotationFlow: Flow<Int> = callbackFlow {
-        val listener = object : IRotationProvider.Listener {
-            override fun onOrientationChanged(rotation: Int) {
-                trySend(rotation)
-            }
-        }
-        rotationProvider.addListener(listener)
-        awaitClose { rotationProvider.removeListener(listener) }
-    }
+    /**
+     * A flow of device rotation.
+     * `SensorRotationProvider` follows the orientation of the sensor, so it will change when the
+     * device is rotated.
+     * If the application orientation is locked, you should use `DisplayRotationProvider` instead.
+     */
+    private val rotationProvider = SensorRotationProvider(context).asFlowProvider()
+    val rotationFlow: Flow<Int> = rotationProvider.rotationFlow
 
     companion object {
         @Volatile

services/src/main/java/io/github/thibaultbee/streampack/services/DefaultScreenRecorderService.kt

@@ -37,7 +37,7 @@ import androidx.lifecycle.lifecycleScope
 import io.github.thibaultbee.streampack.core.internal.utils.extensions.rootCause
 import io.github.thibaultbee.streampack.core.logger.Logger
 import io.github.thibaultbee.streampack.core.streamers.DefaultScreenRecorderStreamer
-import io.github.thibaultbee.streampack.core.streamers.orientation.DeviceRotationProvider
+import io.github.thibaultbee.streampack.core.streamers.orientation.SensorRotationProvider
 import io.github.thibaultbee.streampack.core.streamers.orientation.IRotationProvider
 import io.github.thibaultbee.streampack.services.utils.NotificationUtils
 import kotlinx.coroutines.flow.filterNotNull
@@ -78,7 +78,7 @@ abstract class DefaultScreenRecorderService(
     protected var streamer: DefaultScreenRecorderStreamer? = null
         private set
 
-    protected open val rotationProvider: IRotationProvider by lazy { DeviceRotationProvider(this) }
+    protected open val rotationProvider: IRotationProvider by lazy { SensorRotationProvider(this) }
 
     private val binder = ScreenRecorderServiceBinder()
     private val notificationUtils: NotificationUtils by lazy {