react-native-orientation-director 2.5.1 → 2.6.1

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/OrientationSensorsEventListener.kt

@@ -10,12 +10,20 @@ import com.facebook.react.bridge.ReactApplicationContext
 class OrientationSensorsEventListener(
   context: ReactApplicationContext,
 ) : SensorEventListener {
-  private var mSensorManager: SensorManager = context.getSystemService(SENSOR_SERVICE) as SensorManager
+  private var mSensorManager: SensorManager =
+    context.getSystemService(SENSOR_SERVICE) as SensorManager
 
-  private var mAccelerometerSensor: Sensor? = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
-  private var mMagneticFieldSensor: Sensor? = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
+  private var mRotationSensor: Sensor? =
+    mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
+  private var mAccelerometerSensor: Sensor? =
+    mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+  private var mMagneticFieldSensor: Sensor? =
+    mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
 
-  private var hasRequiredSensors: Boolean = mAccelerometerSensor != null && mMagneticFieldSensor != null
+  private var hasRotationSensor: Boolean =
+   mRotationSensor != null
+  private var hasAccelerometerAndMagneticFieldSensors: Boolean =
+    mAccelerometerSensor != null && mMagneticFieldSensor != null
 
   private val accelerometerReading = FloatArray(3)
   private val magnetometerReading = FloatArray(3)
@@ -32,6 +40,59 @@ class OrientationSensorsEventListener(
       return
     }
 
+    if (event.sensor.type == Sensor.TYPE_ROTATION_VECTOR) {
+      computeOrientationFromRotationSensor(event.values);
+      return
+    }
+
+    computeOrientationFromOtherSensors(event)
+  }
+
+  override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+
+  fun enable() {
+    if (hasRotationSensor) {
+      mSensorManager.registerListener(
+        this,
+        mRotationSensor,
+        SensorManager.SENSOR_DELAY_NORMAL,
+        SensorManager.SENSOR_DELAY_UI
+      )
+      return
+    }
+
+    if (hasAccelerometerAndMagneticFieldSensors) {
+      mSensorManager.registerListener(
+        this,
+        mAccelerometerSensor,
+        SensorManager.SENSOR_DELAY_NORMAL,
+        SensorManager.SENSOR_DELAY_UI
+      )
+      mSensorManager.registerListener(
+        this,
+        mMagneticFieldSensor,
+        SensorManager.SENSOR_DELAY_NORMAL,
+        SensorManager.SENSOR_DELAY_UI
+      )
+      return
+    }
+  }
+
+  fun disable() {
+    mSensorManager.unregisterListener(this)
+  }
+
+  private fun computeOrientationFromRotationSensor(values: FloatArray) {
+    val rotationMatrix = FloatArray(9)
+    SensorManager.getRotationMatrixFromVector(rotationMatrix, values)
+
+    val orientationAngles = FloatArray(3)
+    SensorManager.getOrientation(rotationMatrix, orientationAngles)
+
+    notifyOrientationAnglesChanged(orientationAngles)
+  }
+
+  private fun computeOrientationFromOtherSensors(event: SensorEvent) {
     if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
       System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
     }
@@ -54,6 +115,10 @@ class OrientationSensorsEventListener(
     val orientationAngles = FloatArray(3)
     SensorManager.getOrientation(rotationMatrix, orientationAngles)
 
+    notifyOrientationAnglesChanged(orientationAngles)
+  }
+
+  private fun notifyOrientationAnglesChanged(orientationAngles: FloatArray) {
     if (lastComputedOrientationAngles.contentEquals(orientationAngles)) {
       return
     }
@@ -61,19 +126,4 @@ class OrientationSensorsEventListener(
     onOrientationAnglesChangedCallback?.invoke(orientationAngles)
     lastComputedOrientationAngles = orientationAngles
   }
-
-  override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
-
-  fun enable() {
-    if (!hasRequiredSensors) {
-      return
-    }
-
-    mSensorManager.registerListener(this, mAccelerometerSensor, SensorManager.SENSOR_DELAY_NORMAL)
-    mSensorManager.registerListener(this, mMagneticFieldSensor, SensorManager.SENSOR_DELAY_NORMAL)
-  }
-
-  fun disable() {
-    mSensorManager.unregisterListener(this)
-  }
 }

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

@@ -20,31 +20,47 @@ class Utils(private val context: ReactContext) {
   }
 
   fun convertToDeviceOrientationFrom(orientationAngles: FloatArray): Orientation {
-    val (_, pitchRadians, rollRadians) = orientationAngles;
+    if (orientationAngles.size < 3) {
+      return Orientation.PORTRAIT
+    }
+
+    val (_, pitchRadians, rollRadians) = orientationAngles
 
-    val pitchDegrees = Math.toDegrees(pitchRadians.toDouble()).toFloat()
-    val rollDegrees = Math.toDegrees(rollRadians.toDouble()).toFloat()
+    val pitch = Math.toDegrees(pitchRadians.toDouble()).toFloat()
+    val roll = Math.toDegrees(rollRadians.toDouble()).toFloat()
 
-    // This is needed to account for inaccuracy due to subtle movements such as tilting
-    val tolerance = 20f
+    val faceUpDownPitchTolerance = 30f
 
-    //////////////////////////////////////
-    // 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
-    //
-    //////////////////////////////////////
+    fun isValueCloseTo(value: Float, target: Float, tolerance: Float): Boolean {
+      return value in (target - tolerance)..(target + tolerance)
+    }
 
     return when {
-      rollDegrees.equals(-0f) && (pitchDegrees.equals(0f) || pitchDegrees.equals(-0f)) -> Orientation.FACE_UP
-      rollDegrees.equals(-180f) && (pitchDegrees.equals(0f) || pitchDegrees.equals(-0f)) -> Orientation.FACE_DOWN
-      rollDegrees in tolerance..landscapeRightLimit - tolerance -> Orientation.LANDSCAPE_RIGHT
-      rollDegrees in landscapeLeftLimit + tolerance..-tolerance -> Orientation.LANDSCAPE_LEFT
-      pitchDegrees in portraitLimit..-0f -> 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
     }
   }
 
@@ -86,12 +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;
-  }
 }

package/lib/commonjs/EventEmitter.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _module = _interopRequireWildcard(require("./module.js"));
+var _EventEnum = _interopRequireDefault(require("./types/Event.enum.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+class EventEmitter {
+  static addDeviceOrientationDidChangeListener(callback) {
+    let listener = _module.ModuleEventEmitter.addListener(_EventEnum.default.DeviceOrientationDidChange, callback);
+    if (_reactNative.Platform.OS !== 'android') {
+      return listener;
+    }
+    const listenerCount = _module.ModuleEventEmitter.listenerCount(_EventEnum.default.DeviceOrientationDidChange);
+    if (listenerCount === 1) {
+      _module.default.enableOrientationSensors();
+    }
+    return EventEmitter.createDeviceOrientationListenerProxy(listener);
+  }
+  static addInterfaceOrientationDidChangeListener(callback) {
+    return _module.ModuleEventEmitter.addListener(_EventEnum.default.InterfaceOrientationDidChange, callback);
+  }
+  static addLockDidChangeListener(callback) {
+    return _module.ModuleEventEmitter.addListener(_EventEnum.default.LockDidChange, callback);
+  }
+  static createDeviceOrientationListenerProxy(listener) {
+    const handler = {
+      get(target, propertyKey, receiver) {
+        if (propertyKey === 'remove') {
+          disableOrientationSensorsIfLastListener();
+        }
+        return Reflect.get(target, propertyKey, receiver);
+      }
+    };
+    return new Proxy(listener, handler);
+    function disableOrientationSensorsIfLastListener() {
+      const listenerCount = _module.ModuleEventEmitter.listenerCount(_EventEnum.default.DeviceOrientationDidChange);
+      if (listenerCount === 1) {
+        _module.default.disableOrientationSensors();
+      }
+    }
+  }
+}
+var _default = exports.default = EventEmitter;

package/lib/commonjs/NativeOrientationDirector.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('OrientationDirector');

package/lib/commonjs/RNOrientationDirector.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _module = _interopRequireDefault(require("./module.js"));
+var _OrientationEnum = require("./types/Orientation.enum.js");
+var _AutoRotationEnum = require("./types/AutoRotation.enum.js");
+var _OrientationTypeEnum = require("./types/OrientationType.enum.js");
+var _EventEmitter = _interopRequireDefault(require("./EventEmitter.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class RNOrientationDirector {
+  static _humanReadableOrientationsResource = {
+    [_OrientationEnum.Orientation.unknown]: 'Unknown',
+    [_OrientationEnum.Orientation.portrait]: 'Portrait',
+    [_OrientationEnum.Orientation.portraitUpsideDown]: 'Portrait Upside Down',
+    [_OrientationEnum.Orientation.landscapeLeft]: 'Landscape Left',
+    [_OrientationEnum.Orientation.landscapeRight]: 'Landscape Right',
+    [_OrientationEnum.Orientation.landscape]: 'Landscape',
+    [_OrientationEnum.Orientation.faceUp]: 'Face Up',
+    [_OrientationEnum.Orientation.faceDown]: 'Face Down'
+  };
+  static _humanReadableAutoRotationsResource = {
+    [_AutoRotationEnum.AutoRotation.unknown]: 'Unknown',
+    [_AutoRotationEnum.AutoRotation.enabled]: 'Enabled',
+    [_AutoRotationEnum.AutoRotation.disabled]: 'Disabled'
+  };
+  setHumanReadableOrientations(resource) {
+    RNOrientationDirector._humanReadableOrientationsResource = resource;
+  }
+  setHumanReadableAutoRotations(resource) {
+    RNOrientationDirector._humanReadableAutoRotationsResource = resource;
+  }
+  static getInterfaceOrientation() {
+    return _module.default.getInterfaceOrientation();
+  }
+  static getDeviceOrientation() {
+    return _module.default.getDeviceOrientation();
+  }
+
+  /**
+   * Please be aware that device orientation is not the
+   * same as interface orientation.
+   *
+   * Specifically, landscape left and right are inverted:
+   *
+   * - landscapeLeft in device orientation is landscapeRight in interface orientation
+   * - landscapeRight in device orientation is landscapeLeft in interface orientation
+   *
+   * This is a behavior of the native API.
+   *
+   * When you pass an orientation value, do provide orientationType
+   * as well if the orientation value is not an interface orientation.
+   * Example: when using listenForDeviceOrientationChanges.
+   *
+   * @param orientation any lockable orientation enum value
+   * @param orientationType any orientation type enum value
+   */
+  static lockTo(orientation, orientationType = _OrientationTypeEnum.OrientationType.interface) {
+    if (orientationType === _OrientationTypeEnum.OrientationType.interface) {
+      _module.default.lockTo(orientation);
+      return;
+    }
+    if (orientation === _OrientationEnum.Orientation.landscapeLeft) {
+      _module.default.lockTo(_OrientationEnum.Orientation.landscapeRight);
+      return;
+    }
+    if (orientation === _OrientationEnum.Orientation.landscapeRight) {
+      _module.default.lockTo(_OrientationEnum.Orientation.landscapeLeft);
+      return;
+    }
+    _module.default.lockTo(orientation);
+  }
+  static unlock() {
+    _module.default.unlock();
+  }
+  static isLocked() {
+    return _module.default.isLocked();
+  }
+  static isAutoRotationEnabled() {
+    if (_reactNative.Platform.OS !== 'android') {
+      return _AutoRotationEnum.AutoRotation.unknown;
+    }
+    return _module.default.isAutoRotationEnabled() ? _AutoRotationEnum.AutoRotation.enabled : _AutoRotationEnum.AutoRotation.disabled;
+  }
+  static resetSupportedInterfaceOrientations() {
+    _module.default.resetSupportedInterfaceOrientations();
+  }
+  static listenForDeviceOrientationChanges(callback) {
+    return _EventEmitter.default.addDeviceOrientationDidChangeListener(callback);
+  }
+  static listenForInterfaceOrientationChanges(callback) {
+    return _EventEmitter.default.addInterfaceOrientationDidChangeListener(callback);
+  }
+  static listenForLockChanges(callback) {
+    return _EventEmitter.default.addLockDidChangeListener(callback);
+  }
+  static convertOrientationToHumanReadableString(orientation) {
+    return RNOrientationDirector._humanReadableOrientationsResource[orientation];
+  }
+  static convertAutoRotationToHumanReadableString(autoRotation) {
+    return RNOrientationDirector._humanReadableAutoRotationsResource[autoRotation];
+  }
+
+  /**
+   * This method checks if the given orientation is lockable
+   * by interface perspective.
+   *
+   * All orientations are lockable except for unknown, faceUp
+   * and faceDown.
+   *
+   * This method is useful when you want to lock the interface
+   * orientation from a given device orientation.
+   *
+   * Example: with listenForDeviceOrientationChanges
+   *
+   * @param orientation any orientation enum value
+   * @returns true if the orientation is lockable
+   */
+  static isLockableOrientation(orientation) {
+    return !(orientation === _OrientationEnum.Orientation.unknown || orientation === _OrientationEnum.Orientation.faceUp || orientation === _OrientationEnum.Orientation.faceDown);
+  }
+}
+var _default = exports.default = RNOrientationDirector;

package/lib/commonjs/hooks/useDeviceOrientation.hook.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _RNOrientationDirector = _interopRequireDefault(require("../RNOrientationDirector.js"));
+var _OrientationEnum = require("../types/Orientation.enum.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Hook that returns the current device orientation.
+ * It listens for orientation changes and updates the state accordingly.
+ */
+const useDeviceOrientation = () => {
+  const initialRender = (0, _react.useRef)(false);
+  const [orientation, setOrientation] = _react.default.useState(_OrientationEnum.Orientation.unknown);
+  _react.default.useEffect(() => {
+    if (initialRender.current) {
+      return;
+    }
+    initialRender.current = true;
+    _RNOrientationDirector.default.getDeviceOrientation().then(setOrientation);
+  }, []);
+  _react.default.useEffect(() => {
+    const onChange = event => {
+      setOrientation(event.orientation);
+    };
+    const subscription = _RNOrientationDirector.default.listenForDeviceOrientationChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return orientation;
+};
+var _default = exports.default = useDeviceOrientation;

package/lib/commonjs/hooks/useInterfaceOrientation.hook.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _RNOrientationDirector = _interopRequireDefault(require("../RNOrientationDirector.js"));
+var _OrientationEnum = require("../types/Orientation.enum.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Hook that returns the current interface orientation.
+ * It listens for orientation changes and updates the state accordingly.
+ */
+const useInterfaceOrientation = () => {
+  const initialRender = (0, _react.useRef)(false);
+  const [orientation, setOrientation] = _react.default.useState(_OrientationEnum.Orientation.unknown);
+  _react.default.useEffect(() => {
+    if (initialRender.current) {
+      return;
+    }
+    initialRender.current = true;
+    _RNOrientationDirector.default.getInterfaceOrientation().then(setOrientation);
+  }, []);
+  _react.default.useEffect(() => {
+    const onChange = event => {
+      setOrientation(event.orientation);
+    };
+    const subscription = _RNOrientationDirector.default.listenForInterfaceOrientationChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return orientation;
+};
+var _default = exports.default = useInterfaceOrientation;

package/lib/commonjs/hooks/useIsInterfaceOrientationLocked.hook.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _RNOrientationDirector = _interopRequireDefault(require("../RNOrientationDirector.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Hook that returns whether the interface is locked.
+ * It listens for changes and updates the state accordingly.
+ */
+const useIsInterfaceOrientationLocked = () => {
+  const [orientation, setOrientation] = _react.default.useState(() => _RNOrientationDirector.default.isLocked());
+  _react.default.useEffect(() => {
+    const onChange = event => {
+      setOrientation(event.locked);
+    };
+    const subscription = _RNOrientationDirector.default.listenForLockChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return orientation;
+};
+var _default = exports.default = useIsInterfaceOrientationLocked;