expo-rotation-module 1.0.1 → 1.0.3

package/README.md

@@ -49,7 +49,7 @@ import Rotation, {
 
 - `canWrite(): Promise<boolean>` — returns true if the app has `WRITE_SETTINGS` granted (Android M+). Returns `true` on older OS versions.
 - `requestWritePermission(): void` — opens the Android Settings screen where the user can grant the permission for your app.
-- `getRotationState(): Promise<'AUTOROTATE'|'PORTRAIT'|'LANDSCAPE'>` — reads the current global rotation state.
+- `getRotationState(): Promise<'AUTOROTATE'|'PORTRAIT'|'LANDSCAPE'>` — reads the current global rotation state. The module reports the coarse axis (PORTRAIT or LANDSCAPE); within those axes the system sensor still allows regular or inverted orientations when auto-rotate is off.
 - `setRotationState(state): Promise<void>` — sets the rotation state. Rejects with an Error that may contain a `code` property (e.g. `E_PERMISSION`).
 - `getPackageName(): Promise<string>` — returns the package name the native module is using (useful for diagnostics).
 

package/android/src/main/java/ktsierra/expo/rotationmodule/ExpoRotationModule.kt

@@ -2,13 +2,23 @@ package ktsierra.expo.rotationmodule
 
 import android.app.Activity
 import android.content.ContentResolver
+import android.content.Context
 import android.content.Intent
 import android.net.Uri
 import android.os.Build
 import android.provider.Settings
 import android.util.Log
+import android.content.pm.ActivityInfo
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import kotlin.math.atan2
+import kotlin.math.sqrt
+import kotlin.math.abs
+
 
 class ExpoRotationModule : Module() {
   companion object {
@@ -16,6 +26,23 @@ class ExpoRotationModule : Module() {
     const val TAG = "ExpoRotationModule"
   }
 
+  private var orientationListener: android.view.OrientationEventListener? = null
+  private var desiredAxis: String? = null
+  private var lastWrittenRotation: Int = -1
+
+  // Sensor-related fields for tilt detection and debouncing
+  private var sensorManager: SensorManager? = null
+  private var accelSensor: Sensor? = null
+  private var accelListener: SensorEventListener? = null
+  // tilt threshold (degrees) below which device is considered "flat"
+  private val tiltThresholdDegrees = 20f
+  // debounce: must see same rot candidate this many times before writing
+  private var stableCount = 0
+  private val stableRequired = 3
+  private var lastRotCandidate = -1
+  // last measured inclination in degrees (0 = flat, 90 = upright)
+  private var lastInclinationDeg = 90f
+
   override fun definition() = ModuleDefinition {
     Name(NAME)
 
@@ -34,6 +61,36 @@ class ExpoRotationModule : Module() {
       }
     }
 
+    // Expose helpers (optional)
+    Function("startOrientationListener") {
+      val ctx = appContext.activityProvider?.currentActivity ?: appContext.reactContext!!
+      startOrientationListener(ctx)
+      return@Function null
+    }
+
+    Function("stopOrientationListener") {
+      orientationListener?.disable()
+      orientationListener = null
+      desiredAxis = null
+      lastWrittenRotation = -1
+      // unregister accelerometer listener if registered
+      try {
+        if (sensorManager != null && accelListener != null) {
+          sensorManager?.unregisterListener(accelListener)
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "stopOrientationListener sensor unregister error", e)
+      }
+      accelListener = null
+      accelSensor = null
+      sensorManager = null
+      // reset debounce
+      stableCount = 0
+      lastRotCandidate = -1
+      lastInclinationDeg = 90f
+      return@Function null
+    }
+
     Function("requestWritePermission") {
       try {
         val activity: Activity? = appContext.activityProvider?.currentActivity
@@ -86,9 +143,8 @@ class ExpoRotationModule : Module() {
             0
           }
           return@AsyncFunction when (rotation) {
-            0 -> "PORTRAIT"
-            1 -> "LANDSCAPE"
-            3 -> "LANDSCAPE"
+            0, 2 -> "PORTRAIT"
+            1, 3 -> "LANDSCAPE"
             else -> "PORTRAIT"
           }
         }
@@ -104,23 +160,36 @@ class ExpoRotationModule : Module() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.System.canWrite(ctx)) {
           throw Exception("E_PERMISSION: WRITE_SETTINGS not granted")
         }
-        val resolver: ContentResolver = ctx.contentResolver
+
         when (state) {
           "AUTOROTATE" -> {
+            // Restore system auto-rotate
+            val resolver: ContentResolver = ctx.contentResolver
             Settings.System.putInt(resolver, Settings.System.ACCELEROMETER_ROTATION, 1)
+            // unregister listener if present
+            orientationListener?.disable()
+            orientationListener = null
+            desiredAxis = null
+            lastWrittenRotation = -1
           }
           "PORTRAIT" -> {
+            // disable system auto-rotate and enable axis-lock with sensor flips on portrait axis
+            val resolver: ContentResolver = ctx.contentResolver
             Settings.System.putInt(resolver, Settings.System.ACCELEROMETER_ROTATION, 0)
-            Settings.System.putInt(resolver, Settings.System.USER_ROTATION, 0)
+            desiredAxis = "PORTRAIT"
+            startOrientationListener(ctx)
           }
           "LANDSCAPE" -> {
+            val resolver: ContentResolver = ctx.contentResolver
             Settings.System.putInt(resolver, Settings.System.ACCELEROMETER_ROTATION, 0)
-            Settings.System.putInt(resolver, Settings.System.USER_ROTATION, 1)
+            desiredAxis = "LANDSCAPE"
+            startOrientationListener(ctx)
           }
           else -> {
             throw Exception("E_INVALID_STATE: Invalid rotation state: $state")
           }
         }
+
         return@AsyncFunction null
       } catch (e: Exception) {
         Log.e(TAG, "setRotationState error", e)
@@ -128,4 +197,94 @@ class ExpoRotationModule : Module() {
       }
     }
   }
+
+  private fun startOrientationListener(ctx: Context) {
+    // If listener already exists, do nothing
+    if (orientationListener != null) return
+
+    // set up accelerometer to measure inclination
+    sensorManager = ctx.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+    accelSensor = sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+    accelListener = object : SensorEventListener {
+      override fun onSensorChanged(event: SensorEvent) {
+        val x = event.values[0].toDouble()
+        val y = event.values[1].toDouble()
+        val z = event.values[2].toDouble()
+        val g = sqrt(x * x + y * y + z * z)
+        if (g > 0.0) {
+          var inclRad = atan2(z, sqrt(x * x + y * y))
+          var inclDeg = Math.toDegrees(inclRad).toFloat()
+          inclDeg = abs(inclDeg)
+          // clamp
+          if (inclDeg > 90f) inclDeg = 90f
+          lastInclinationDeg = inclDeg
+        }
+      }
+
+      override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+    }
+    if (accelSensor != null) {
+      // Use UI delay for reasonable responsiveness
+      sensorManager?.registerListener(accelListener, accelSensor, SensorManager.SENSOR_DELAY_UI)
+    }
+
+    orientationListener = object : android.view.OrientationEventListener(ctx) {
+      override fun onOrientationChanged(orientation: Int) {
+        // orientation: 0..359 degrees, or ORIENTATION_UNKNOWN (-1)
+        if (orientation == android.view.OrientationEventListener.ORIENTATION_UNKNOWN) return
+        // Normalize to one of the 4 Android rotations: 0, 90, 180, 270
+        val rot = when {
+          orientation in 315..359 || orientation in 0..44 -> 0
+          orientation in 45..134 -> 1
+          orientation in 135..224 -> 2
+          else -> 3
+        }
+
+        try {
+          val resolver: ContentResolver = ctx.contentResolver
+
+          // If device is nearly flat, skip writing to avoid noise
+          if (lastInclinationDeg < tiltThresholdDegrees) {
+            lastRotCandidate = -1
+            stableCount = 0
+            return
+          }
+
+          // Debounce: require several consistent buckets
+          if (rot == lastRotCandidate) {
+            stableCount += 1
+          } else {
+            lastRotCandidate = rot
+            stableCount = 1
+          }
+          if (stableCount < stableRequired) return
+
+          // desiredAxis controls whether we want portrait or landscape axis.
+          when (desiredAxis) {
+            "PORTRAIT" -> {
+              // We want 0 or 2 depending on angle
+              val target = if (rot == 2) 2 else 0
+              if (lastWrittenRotation != target) {
+                Settings.System.putInt(resolver, Settings.System.USER_ROTATION, target)
+                lastWrittenRotation = target
+              }
+            }
+            "LANDSCAPE" -> {
+              // We want 1 or 3 depending on angle
+              val target = if (rot == 1) 3 else if (rot == 3) 1 else if (rot == 2) 1 else 3
+              // swapped mapping: 90 -> 3, 270 -> 1, fallback 180->1, 0->3
+              if (lastWrittenRotation != target) {
+                Settings.System.putInt(resolver, Settings.System.USER_ROTATION, target)
+                lastWrittenRotation = target
+              }
+            }
+          }
+        } catch (e: Exception) {
+          Log.e(TAG, "orientation listener write error", e)
+        }
+      }
+    }
+
+    orientationListener?.enable()
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-rotation-module",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Screen Orientation Native Module",
   "main": "index.js",
   "types": "src/index.d.ts",

package/src/index.d.ts

@@ -1,4 +1,4 @@
-export type RotationState = "AUTOROTATE" | "PORTRAIT" | "LANDSCAPE";
+export type RotationState = 'AUTOROTATE' | 'PORTRAIT' | 'LANDSCAPE';
 
 export function canWrite(): Promise<boolean>;
 export function requestWritePermission(): void;