expo-rotation-module 1.0.1 → 1.0.2

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,11 +2,13 @@ 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
 
@@ -16,6 +18,10 @@ class ExpoRotationModule : Module() {
     const val TAG = "ExpoRotationModule"
   }
 
+  private var orientationListener: android.view.OrientationEventListener? = null
+  private var desiredAxis: String? = null
+  private var lastWrittenRotation: Int = -1
+
   override fun definition() = ModuleDefinition {
     Name(NAME)
 
@@ -34,6 +40,20 @@ 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
+      return@Function null
+    }
+
     Function("requestWritePermission") {
       try {
         val activity: Activity? = appContext.activityProvider?.currentActivity
@@ -86,9 +106,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 +123,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 +160,51 @@ class ExpoRotationModule : Module() {
       }
     }
   }
+
+  private fun startOrientationListener(ctx: Context) {
+    // If listener already exists, do nothing
+    if (orientationListener != null) return
+
+    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
+          // 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.2",
   "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;