Refine FoldableAdapter: sealed class, StateFlow, API level check

- Convert HingeState to sealed class with Unavailable and Available(angle) states
- Remove getCachedHingeState() method, use StateFlow.value directly
- Add @RequiresApi(Build.VERSION_CODES.R) annotations
- Add API level 30 minimum requirement check in CreateConstraintUseCase
- Update ConstraintSnapshot to use sealed class pattern matching

Co-authored-by: sds100 <16245954+sds100@users.noreply.github.com>

Author: Copilot

base/src/main/java/io/github/sds100/keymapper/base/constraints/ConstraintSnapshot.kt

@@ -9,6 +9,7 @@ import io.github.sds100.keymapper.system.camera.CameraAdapter
 import io.github.sds100.keymapper.system.devices.DevicesAdapter
 import io.github.sds100.keymapper.system.display.DisplayAdapter
 import io.github.sds100.keymapper.system.hinge.FoldableAdapter
+import io.github.sds100.keymapper.system.hinge.HingeState
 import io.github.sds100.keymapper.system.inputmethod.InputMethodAdapter
 import io.github.sds100.keymapper.system.lock.LockScreenAdapter
 import io.github.sds100.keymapper.system.media.MediaAdapter
@@ -144,13 +145,17 @@ class LazyConstraintSnapshot(
             is ConstraintData.Discharging -> !isCharging
 
             is ConstraintData.HingeClosed -> {
-                val hingeState = foldableAdapter.getCachedHingeState()
-                hingeState.isAvailable && hingeState.angle != null && hingeState.angle < 30f
+                when (val state = foldableAdapter.hingeState.value) {
+                    is HingeState.Available -> state.angle < 30f
+                    is HingeState.Unavailable -> false
+                }
             }
 
             is ConstraintData.HingeOpen -> {
-                val hingeState = foldableAdapter.getCachedHingeState()
-                hingeState.isAvailable && hingeState.angle != null && hingeState.angle >= 150f
+                when (val state = foldableAdapter.hingeState.value) {
+                    is HingeState.Available -> state.angle >= 150f
+                    is HingeState.Unavailable -> false
+                }
             }
 
             // The keyguard manager still reports the lock screen as showing if you are in

base/src/main/java/io/github/sds100/keymapper/base/constraints/CreateConstraintUseCase.kt

@@ -1,6 +1,7 @@
 package io.github.sds100.keymapper.base.constraints
 
 import android.content.pm.PackageManager
+import android.os.Build
 import io.github.sds100.keymapper.common.utils.KMError
 import io.github.sds100.keymapper.data.Keys
 import io.github.sds100.keymapper.data.repositories.PreferenceRepository
@@ -30,6 +31,11 @@ class CreateConstraintUseCaseImpl @Inject constructor(
                     return KMError.SystemFeatureNotSupported(PackageManager.FEATURE_CAMERA_FLASH)
                 }
             }
+            ConstraintId.HINGE_CLOSED, ConstraintId.HINGE_OPEN -> {
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+                    return KMError.SdkVersionTooLow(Build.VERSION_CODES.R)
+                }
+            }
             else -> Unit
         }
 

system/src/main/java/io/github/sds100/keymapper/system/hinge/AndroidFoldableAdapter.kt

@@ -5,6 +5,8 @@ import android.hardware.Sensor
 import android.hardware.SensorEvent
 import android.hardware.SensorEventListener
 import android.hardware.SensorManager
+import android.os.Build
+import androidx.annotation.RequiresApi
 import androidx.core.content.getSystemService
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -14,12 +16,13 @@ import timber.log.Timber
 import javax.inject.Inject
 import javax.inject.Singleton
 
+@RequiresApi(Build.VERSION_CODES.R)
 @Singleton
 class AndroidFoldableAdapter @Inject constructor(
     @ApplicationContext private val context: Context,
 ) : FoldableAdapter {
 
-    private val _hingeState = MutableStateFlow(HingeState(isAvailable = false, angle = null))
+    private val _hingeState = MutableStateFlow<HingeState>(HingeState.Unavailable)
     override val hingeState: StateFlow<HingeState> = _hingeState.asStateFlow()
 
     private val sensorManager: SensorManager? = context.getSystemService()
@@ -30,10 +33,7 @@ class AndroidFoldableAdapter @Inject constructor(
             event?.let {
                 if (it.sensor.type == Sensor.TYPE_HINGE_ANGLE && it.values.isNotEmpty()) {
                     val angle = it.values[0]
-                    _hingeState.value = HingeState(
-                        isAvailable = true,
-                        angle = angle,
-                    )
+                    _hingeState.value = HingeState.Available(angle)
                 }
             }
         }
@@ -58,13 +58,11 @@ class AndroidFoldableAdapter @Inject constructor(
                 Timber.d("Hinge angle sensor monitoring started")
             } catch (e: Exception) {
                 Timber.e(e, "Failed to start hinge angle sensor monitoring")
-                _hingeState.value = HingeState(isAvailable = false, angle = null)
+                _hingeState.value = HingeState.Unavailable
             }
         } else {
             Timber.d("Hinge angle sensor not available on this device")
-            _hingeState.value = HingeState(isAvailable = false, angle = null)
+            _hingeState.value = HingeState.Unavailable
         }
     }
-
-    override fun getCachedHingeState(): HingeState = _hingeState.value
 }

system/src/main/java/io/github/sds100/keymapper/system/hinge/FoldableAdapter.kt

@@ -1,31 +1,31 @@
 package io.github.sds100.keymapper.system.hinge
 
-import kotlinx.coroutines.flow.Flow
+import androidx.annotation.RequiresApi
+import android.os.Build
+import kotlinx.coroutines.flow.StateFlow
 
 /**
  * Represents the state of a foldable device hinge.
  */
-data class HingeState(
+sealed class HingeState {
     /**
-     * True if the device has a hinge and it is currently available.
+     * Hinge sensor is not available on this device.
      */
-    val isAvailable: Boolean,
+    data object Unavailable : HingeState()
+
     /**
-     * The angle in degrees of the hinge. Null if hinge is not available.
+     * Hinge sensor is available and reporting angle.
+     * @param angle The angle in degrees of the hinge.
      * 0 degrees means the device is closed/flat.
      * 180 degrees means the device is fully open.
      */
-    val angle: Float?,
-)
+    data class Available(val angle: Float) : HingeState()
+}
 
+@RequiresApi(Build.VERSION_CODES.R)
 interface FoldableAdapter {
     /**
-     * Flow that emits the current hinge state.
-     */
-    val hingeState: Flow<HingeState>
-
-    /**
-     * Get the current cached hinge state.
+     * StateFlow that emits the current hinge state.
      */
-    fun getCachedHingeState(): HingeState
+    val hingeState: StateFlow<HingeState>
 }