react-native-orientation-director 2.6.0 → 2.6.2

package/README.md

@@ -78,23 +78,33 @@ This library uses a custom broadcast receiver to handle the manual orientation c
 autorotation feature and the system prompts the user to rotate the device, the library will listen to the broadcast
 sent by the MainActivity and update the interface orientation accordingly.
 
-To allow the library to listen to the broadcast, you need to override the `onConfigurationChanged` method in your
-MainActivity file, as shown below:
+To allow the library to listen to the broadcast, you need to override the `onConfigurationChanged` method in MainActivity.kt as shown below:
 
 ```kotlin
-override fun onConfigurationChanged(newConfig: Configuration) {
-    super.onConfigurationChanged(newConfig)
+// ...
 
-    val orientationDirectorCustomAction =
-      "${packageName}.${ConfigurationChangedBroadcastReceiver.CUSTOM_INTENT_ACTION}"
+import android.content.Intent
+import android.content.res.Configuration
+import com.orientationdirector.implementation.ConfigurationChangedBroadcastReceiver
 
-    val intent =
-      Intent(orientationDirectorCustomAction).apply {
-        putExtra("newConfig", newConfig)
-        setPackage(packageName)
-      }
+class MainActivity : ReactActivity() {
 
-    this.sendBroadcast(intent)
+  // ...
+
+  override fun onConfigurationChanged(newConfig: Configuration) {
+      super.onConfigurationChanged(newConfig)
+
+      val orientationDirectorCustomAction =
+        "${packageName}.${ConfigurationChangedBroadcastReceiver.CUSTOM_INTENT_ACTION}"
+
+      val intent =
+        Intent(orientationDirectorCustomAction).apply {
+          putExtra("newConfig", newConfig)
+          setPackage(packageName)
+        }
+
+      this.sendBroadcast(intent)
+  }
 }
 ```
 

package/android/src/main/java/com/orientationdirector/implementation/OrientationDirectorModuleImpl.kt

@@ -33,7 +33,7 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     mAutoRotationObserver.enable()
 
     mBroadcastReceiver.setOnReceiveCallback {
-      adaptInterfaceTo(lastDeviceOrientation, false)
+      checkInterfaceOrientation(false)
     }
 
     context.addLifecycleEventListener(mLifecycleListener)
@@ -113,7 +113,7 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     context.currentActivity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
 
     updateIsLockedTo(false)
-    adaptInterfaceTo(lastDeviceOrientation)
+    checkInterfaceOrientation()
   }
 
   fun resetSupportedInterfaceOrientations() {
@@ -161,7 +161,7 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     mEventManager.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
     lastDeviceOrientation = deviceOrientation
 
-    adaptInterfaceTo(deviceOrientation)
+    checkInterfaceOrientation()
 
     if (!didComputeInitialDeviceOrientation) {
       didComputeInitialDeviceOrientation = true
@@ -169,50 +169,35 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     }
   }
 
-  private fun adaptInterfaceTo(deviceOrientation: Orientation, checkLastAutoRotationStatus: Boolean = true) {
-    if (checkLastAutoRotationStatus && !mAutoRotationObserver.getLastAutoRotationStatus()) {
+  private fun checkInterfaceOrientation(skipIfAutoRotationIsDisabled: Boolean = true) {
+    if (skipIfAutoRotationIsDisabled && !mAutoRotationObserver.getLastAutoRotationStatus()) {
       return
     }
 
-    val supportsLandscape =
-      mUtils.getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
-    if (isLocked && !supportsLandscape) {
+    if (isLocked) {
       return
     }
 
-    var newInterfaceOrientation = mUtils.convertToInterfaceOrientationFrom(deviceOrientation);
-
-    /**
-     * When the device orientation is either face up or face down,
-     * we can't match it to an interface orientation, because
-     * it could be either portrait or any landscape.
-     * So we read it from the system itself.
-     */
-    if (newInterfaceOrientation == Orientation.UNKNOWN) {
+    if (lastDeviceOrientation != Orientation.LANDSCAPE_RIGHT && lastDeviceOrientation != Orientation.LANDSCAPE_LEFT) {
       val rotation = mUtils.getInterfaceRotation()
-      newInterfaceOrientation = mUtils.convertToOrientationFromScreenRotation(rotation)
-    }
+      val newInterfaceOrientation = mUtils.convertToOrientationFromScreenRotation(rotation)
 
-    /**
-     * This differs from iOS because we can't read the actual orientation of the interface,
-     * we read its rotation.
-     * This means that even if the requestedOrientation of the currentActivity is locked to landscape
-     * it reads every possible orientation and this is not what we want.
-     * Instead, we check that its value is either LANDSCAPE_RIGHT or LANDSCAPE_LEFT, otherwise we
-     * exit
-     */
-    val newInterfaceOrientationIsNotLandscape =
-      newInterfaceOrientation != Orientation.LANDSCAPE_RIGHT
-        && newInterfaceOrientation != Orientation.LANDSCAPE_LEFT;
-    if (supportsLandscape && newInterfaceOrientationIsNotLandscape) {
+      updateLastInterfaceOrientationTo(newInterfaceOrientation)
       return
     }
 
-    if (newInterfaceOrientation == lastInterfaceOrientation) {
-      return
-    }
+    /**
+     * The reason we invert the interface orientation is to match iOS behavior with
+     * UIInterfaceOrientation when device is in landscape mode
+     */
+    val interfaceOrientationBasedOnDeviceOne =
+      if (lastDeviceOrientation == Orientation.LANDSCAPE_RIGHT) {
+        Orientation.LANDSCAPE_LEFT
+      } else {
+        Orientation.LANDSCAPE_RIGHT
+      }
 
-    updateLastInterfaceOrientationTo(newInterfaceOrientation)
+    updateLastInterfaceOrientationTo(interfaceOrientationBasedOnDeviceOne)
   }
 
   private fun updateIsLockedTo(value: Boolean) {
@@ -221,6 +206,10 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
   }
 
   private fun updateLastInterfaceOrientationTo(value: Orientation) {
+    if (value == lastInterfaceOrientation) {
+      return
+    }
+
     lastInterfaceOrientation = value
     mEventManager.sendInterfaceOrientationDidChange(value.ordinal)
   }

package/android/src/main/java/com/orientationdirector/implementation/Utils.kt

@@ -20,38 +20,47 @@ class Utils(private val context: ReactContext) {
   }
 
   fun convertToDeviceOrientationFrom(orientationAngles: FloatArray): Orientation {
-    val (_, pitchRadians, rollRadians) = orientationAngles;
-
-    val pitchDegrees = Math.toDegrees(pitchRadians.toDouble()).toFloat()
-    val rollDegrees = Math.toDegrees(rollRadians.toDouble()).toFloat()
-
-    // This is needed to account for inaccuracy due to subtle movements such as tilting
-    val pitchToleranceDefault = 5f
-    val rollTolerance = 0f
-    val toleranceForFaceUpOrDown = 5f;
-
-    //////////////////////////////////////
-    // These limits are set based on SensorManager.getOrientation reference
-    // https://developer.android.com/develop/sensors-and-location/sensors/sensors_position#sensors-pos-orient
-    //
-    val portraitLimit = -90f
-    val landscapeRightLimit = 180f
-    val landscapeLeftLimit = -180f
-    //
-    //////////////////////////////////////
-
-    val isPitchInLandscapeModeRange =
-      checkIfValueIsBetweenTolerance(pitchDegrees, pitchToleranceDefault)
-    val isPitchCloseToFaceUpOrDown =
-      checkIfValueIsBetweenTolerance(pitchDegrees, toleranceForFaceUpOrDown)
+    if (orientationAngles.size < 3) {
+      return Orientation.PORTRAIT
+    }
+
+    val (_, pitchRadians, rollRadians) = orientationAngles
+
+    val pitch = Math.toDegrees(pitchRadians.toDouble()).toFloat()
+    val roll = Math.toDegrees(rollRadians.toDouble()).toFloat()
+
+    val faceUpDownPitchTolerance = 30f
+
+    fun isValueCloseTo(value: Float, target: Float, tolerance: Float): Boolean {
+      return value in (target - tolerance)..(target + tolerance)
+    }
 
     return when {
-      checkIfRollIsCloseToFaceUp(rollDegrees) && isPitchCloseToFaceUpOrDown -> Orientation.FACE_UP
-      checkIfRollIsCloseToFaceDown(rollDegrees) && isPitchCloseToFaceUpOrDown -> Orientation.FACE_DOWN
-      rollDegrees in rollTolerance..landscapeRightLimit - rollTolerance && isPitchInLandscapeModeRange -> Orientation.LANDSCAPE_RIGHT
-      rollDegrees in landscapeLeftLimit + rollTolerance..-rollTolerance && isPitchInLandscapeModeRange -> Orientation.LANDSCAPE_LEFT
-      pitchDegrees in portraitLimit..pitchToleranceDefault -> Orientation.PORTRAIT
-      else -> Orientation.PORTRAIT_UPSIDE_DOWN
+      // Face up: device is lying flat with screen up
+      isValueCloseTo(pitch, 0f, faceUpDownPitchTolerance) &&
+        isValueCloseTo(roll, 0f, faceUpDownPitchTolerance) -> Orientation.FACE_UP
+
+      // Face down: device is lying flat with screen down
+      isValueCloseTo(pitch, 0f, faceUpDownPitchTolerance) &&
+        (isValueCloseTo(roll, 180f, faceUpDownPitchTolerance) || isValueCloseTo(
+          roll,
+          -180f,
+          faceUpDownPitchTolerance
+        )) -> Orientation.FACE_DOWN
+
+      // Portrait
+      isValueCloseTo(pitch, -90f, 45f) -> Orientation.PORTRAIT
+
+      // Portrait upside down
+      isValueCloseTo(pitch, 90f, 45f) -> Orientation.PORTRAIT_UPSIDE_DOWN
+
+      // Landscape left
+      isValueCloseTo(roll, -90f, 45f) -> Orientation.LANDSCAPE_LEFT
+
+      // Landscape right
+      isValueCloseTo(roll, 90f, 45f) -> Orientation.LANDSCAPE_RIGHT
+
+      else -> Orientation.PORTRAIT
     }
   }
 
@@ -93,32 +102,4 @@ class Utils(private val context: ReactContext) {
       else -> Orientation.UNKNOWN
     }
   }
-
-  fun getRequestedOrientation(): Int {
-    if (context.currentActivity?.requestedOrientation == null) {
-      return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
-    }
-
-    return context.currentActivity!!.requestedOrientation;
-  }
-
-  private fun checkIfValueIsBetweenTolerance(value: Float, tolerance: Float): Boolean {
-    return value > -tolerance && value < tolerance
-  }
-
-  private fun checkIfRollIsCloseToFaceDown(value: Float): Boolean {
-    val landscapeLimit = 180f
-    val faceDownLimit = 170f
-
-    return value in faceDownLimit..landscapeLimit  ||
-      value in -landscapeLimit..-faceDownLimit;
-  }
-
-  private fun checkIfRollIsCloseToFaceUp(value: Float): Boolean {
-    val landscapeLimit = 0f
-    val faceUpLimit = 10f
-
-    return value in landscapeLimit..faceUpLimit ||
-      value in -faceUpLimit..-landscapeLimit
-  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-orientation-director",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "A Modern React Native library that allows you to access orientation",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/module/src/index.d.ts",

package/plugin/build/withRNOrientationAppDelegate.js

@@ -41,7 +41,7 @@ function getCompatibleFileUpdater(language) {
     }
 }
 function swiftFileUpdater(originalContents, sdkVersion) {
-    const methodPrefix = !sdkVersion?.includes('53') ? 'override' : '';
+    const methodPrefix = computeMethodPrefix(sdkVersion);
     const supportedInterfaceOrientationsForCodeBlock = `\n  ${methodPrefix} func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
     return OrientationDirector.getSupportedInterfaceOrientationsForWindow()
   }\n`;
@@ -56,6 +56,20 @@ function swiftFileUpdater(originalContents, sdkVersion) {
         comment: '// React Native Orientation Director',
     });
     return results.contents;
+    function computeMethodPrefix(_sdkVersion) {
+        if (!_sdkVersion) {
+            return '';
+        }
+        const sdkVersionAsNumber = Number(_sdkVersion);
+        if (Number.isNaN(sdkVersionAsNumber)) {
+            return '';
+        }
+        if (sdkVersionAsNumber >= 53) {
+            return '';
+        }
+        // Older SDK versions need the override keyword
+        return 'override';
+    }
 }
 function objCFileUpdater(originalContents) {
     const libraryHeaderImportCodeBlock = '#import "OrientationDirector.h"\n';