react-native-orientation-director 1.1.0 → 1.2.1

package/android/src/main/java/com/orientationdirector/OrientationDirectorModule.kt

@@ -38,9 +38,19 @@ class OrientationDirectorModule internal constructor(context: ReactApplicationCo
     orientationDirectorImpl.unlock()
   }
 
+  @ReactMethod()
+  override fun resetSupportedInterfaceOrientations() {
+    orientationDirectorImpl.resetSupportedInterfaceOrientations()
+  }
+
   @ReactMethod(isBlockingSynchronousMethod = true)
   override fun isLocked(): Boolean {
-    return orientationDirectorImpl.isLocked
+    return orientationDirectorImpl.getIsLocked()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun isAutoRotationEnabled(): Boolean {
+    return orientationDirectorImpl.getIsAutoRotationEnabled()
   }
 
   @ReactMethod()

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

@@ -0,0 +1,45 @@
+package com.orientationdirector.implementation
+
+import android.database.ContentObserver
+import android.os.Handler
+import android.provider.Settings
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+
+class OrientationAutoRotationObserver(val context: ReactContext, handler: Handler?) : ContentObserver(handler) {
+  private var lastAutoRotationStatus: Boolean = isAutoRotationEnabled()
+
+  fun getLastAutoRotationStatus(): Boolean {
+    return lastAutoRotationStatus
+  }
+
+  override fun onChange(selfChange: Boolean) {
+    super.onChange(selfChange)
+    val status = isAutoRotationEnabled()
+    lastAutoRotationStatus = status
+  }
+
+  fun enable() {
+    context.contentResolver.registerContentObserver(
+      Settings.System.getUriFor(Settings.System.ACCELEROMETER_ROTATION),
+      true,
+      this,
+    )
+  }
+
+  fun disable() {
+    context.contentResolver.unregisterContentObserver(this)
+  }
+
+  private fun isAutoRotationEnabled(): Boolean {
+    return try {
+      Settings.System.getInt(context.contentResolver, Settings.System.ACCELEROMETER_ROTATION) == 1;
+    } catch (ex: Settings.SettingNotFoundException) {
+      false
+    }
+  }
+
+  companion object {
+    const val NAME = "AutoRotationObserver"
+  }
+}

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

@@ -1,20 +1,26 @@
 package com.orientationdirector.implementation
 
 import android.content.pm.ActivityInfo
+import android.os.Handler
+import android.os.Looper
 import com.facebook.react.bridge.ReactApplicationContext
 
 class OrientationDirectorImpl internal constructor(private val context: ReactApplicationContext) {
   private var mUtils = OrientationDirectorUtilsImpl(context)
   private var mEventEmitter = OrientationEventManager(context)
   private var mSensorListener = OrientationSensorListener(context)
+  private var mAutoRotationObserver = OrientationAutoRotationObserver(
+    context, Handler(
+      Looper.getMainLooper()
+    )
+  )
   private var mLifecycleListener = OrientationLifecycleListener()
 
   private var initialSupportedInterfaceOrientations = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
   private var lastInterfaceOrientation = Orientation.UNKNOWN
   private var lastDeviceOrientation = Orientation.UNKNOWN
   private var initialized = false
-
-  var isLocked: Boolean = false
+  private var isLocked: Boolean = false
 
   init {
     mSensorListener.setOnOrientationChangedCallback { orientation ->
@@ -27,19 +33,25 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
       mSensorListener.disable()
     }
 
+    mAutoRotationObserver.enable()
+
     context.addLifecycleEventListener(mLifecycleListener)
     mLifecycleListener.setOnHostResumeCallback {
       if (mSensorListener.canDetectOrientation()) {
         mSensorListener.enable()
       }
+
+      mAutoRotationObserver.enable()
     }
     mLifecycleListener.setOnHostPauseCallback {
       if (initialized) {
         mSensorListener.disable()
+        mAutoRotationObserver.disable()
       }
     }
     mLifecycleListener.setOnHostDestroyCallback {
       mSensorListener.disable()
+      mAutoRotationObserver.disable()
     }
 
     initialSupportedInterfaceOrientations =
@@ -59,20 +71,35 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     return lastDeviceOrientation
   }
 
-  fun lockTo(jsOrientation: Int) {
-    val interfaceOrientation = mUtils.getOrientationFromJsOrientation(jsOrientation)
+  fun getIsLocked(): Boolean {
+    return isLocked
+  }
+
+  fun getIsAutoRotationEnabled(): Boolean {
+    return mAutoRotationObserver.getLastAutoRotationStatus()
+  }
+
+  fun lockTo(rawJsOrientation: Int) {
+    val jsOrientation = mUtils.getOrientationFromJsOrientation(rawJsOrientation)
     val screenOrientation =
-      mUtils.getActivityOrientationFrom(interfaceOrientation)
+      mUtils.getActivityOrientationFrom(jsOrientation)
     context.currentActivity?.requestedOrientation = screenOrientation
-    mEventEmitter.sendInterfaceOrientationDidChange(interfaceOrientation.ordinal)
-    lastInterfaceOrientation = interfaceOrientation
+
     updateIsLockedTo(true)
+    updateLastInterfaceOrientationTo(jsOrientation)
   }
 
   fun unlock() {
     context.currentActivity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+
     updateIsLockedTo(false)
-    adaptInterfaceTo(getDeviceOrientation())
+    adaptInterfaceTo(lastDeviceOrientation)
+  }
+
+  fun resetSupportedInterfaceOrientations() {
+    context.currentActivity?.requestedOrientation = initialSupportedInterfaceOrientations
+    updateIsLockedTo(initIsLocked())
+    updateLastInterfaceOrientationTo(initInterfaceOrientation())
   }
 
   private fun initInterfaceOrientation(): Orientation {
@@ -106,16 +133,20 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
   }
 
   private fun adaptInterfaceTo(deviceOrientation: Orientation) {
+    if (!mAutoRotationObserver.getLastAutoRotationStatus()) {
+      return
+    }
+
     if (isLocked) {
       return
     }
 
-    if (lastInterfaceOrientation == deviceOrientation) {
+    val newInterfaceOrientation = mUtils.getInterfaceOrientationFromDeviceOrientation(deviceOrientation);
+    if (newInterfaceOrientation == lastInterfaceOrientation) {
       return
     }
 
-    lastInterfaceOrientation = deviceOrientation
-    mEventEmitter.sendInterfaceOrientationDidChange(lastInterfaceOrientation.ordinal)
+    updateLastInterfaceOrientationTo(newInterfaceOrientation)
   }
 
   private fun updateIsLockedTo(value: Boolean) {
@@ -123,6 +154,11 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     isLocked = value
   }
 
+  private fun updateLastInterfaceOrientationTo(value: Orientation) {
+    lastInterfaceOrientation = value
+    mEventEmitter.sendInterfaceOrientationDidChange(value.ordinal)
+  }
+
   companion object {
     const val NAME = "OrientationDirectorImpl"
   }

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

@@ -3,6 +3,7 @@ package com.orientationdirector.implementation
 import android.content.Context
 import android.content.pm.ActivityInfo
 import android.os.Build
+import android.provider.Settings
 import android.view.Surface
 import android.view.WindowManager
 import com.facebook.react.bridge.ReactContext
@@ -63,4 +64,14 @@ class OrientationDirectorUtilsImpl(val context: ReactContext) {
       else -> Orientation.PORTRAIT
     }
   }
+
+  fun getInterfaceOrientationFromDeviceOrientation(deviceOrientation: Orientation): Orientation {
+    return when(deviceOrientation) {
+      Orientation.PORTRAIT -> Orientation.PORTRAIT
+      Orientation.LANDSCAPE_RIGHT -> Orientation.LANDSCAPE_LEFT
+      Orientation.PORTRAIT_UPSIDE_DOWN -> Orientation.PORTRAIT_UPSIDE_DOWN
+      Orientation.LANDSCAPE_LEFT -> Orientation.LANDSCAPE_RIGHT
+      else -> Orientation.UNKNOWN
+    }
+  }
 }

package/android/src/oldarch/OrientationDirectorSpec.kt

@@ -10,8 +10,9 @@ abstract class OrientationDirectorSpec internal constructor(context: ReactApplic
   abstract fun getDeviceOrientation(promise: Promise)
   abstract fun lockTo(orientation: Double)
   abstract fun unlock()
-
+  abstract fun resetSupportedInterfaceOrientations()
   abstract fun isLocked(): Boolean
+  abstract fun isAutoRotationEnabled(): Boolean
   abstract fun addListener(eventName: String)
   abstract fun removeListeners(count: Double)
 }

package/ios/OrientationDirector.mm

@@ -99,7 +99,7 @@ RCT_EXPORT_METHOD(lockTo:(double)jsOrientation)
 {
     NSNumber *jsOrientationNumber = @(jsOrientation);
     dispatch_async(dispatch_get_main_queue(), ^{
-        [_director lockToJsOrientation:jsOrientationNumber];
+        [_director lockToRawJsOrientation:jsOrientationNumber];
     });
 }
 
@@ -123,6 +123,18 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isLocked)
     return @([_director isLocked]);
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)resetSupportedInterfaceOrientations
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(resetSupportedInterfaceOrientations)
+#endif
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [_director resetSupportedInterfaceOrientations];
+    });
+}
+
+
 // Don't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:

package/ios/implementation/OrientationDirectorImpl.swift

@@ -48,23 +48,48 @@ import UIKit
         return lastDeviceOrientation
     }
 
-    @objc public func lockTo(jsOrientation: NSNumber) {
-        let orientation = OrientationDirectorUtils.getOrientationFrom(jsOrientation: jsOrientation)
-        let mask = OrientationDirectorUtils.getMaskFrom(orientation: orientation)
-
+    @objc public func lockTo(rawJsOrientation: NSNumber) {
+        let jsOrientation = OrientationDirectorUtils.getOrientationFrom(jsOrientation: rawJsOrientation)
+        let mask = OrientationDirectorUtils.getMaskFrom(jsOrientation: jsOrientation)
         self.requestInterfaceUpdateTo(mask: mask)
 
-        eventManager.sendInterfaceOrientationDidChange(orientationValue: orientation.rawValue)
-        lastInterfaceOrientation = orientation
         updateIsLockedTo(value: true)
+        updateLastInterfaceOrientationTo(value: jsOrientation)
     }
 
     @objc public func unlock() {
         self.requestInterfaceUpdateTo(mask: UIInterfaceOrientationMask.all)
 
-        let deviceOrientation = OrientationDirectorUtils.getOrientationFrom(deviceOrientation: UIDevice.current.orientation)
         updateIsLockedTo(value: false)
-        self.adaptInterfaceTo(deviceOrientation: deviceOrientation)
+        self.adaptInterfaceTo(deviceOrientation: lastDeviceOrientation)
+    }
+
+    @objc public func resetSupportedInterfaceOrientations() {
+        self.supportedInterfaceOrientations = self.initialSupportedInterfaceOrientations
+        self.requestInterfaceUpdateTo(mask: self.supportedInterfaceOrientations)
+        self.updateIsLockedTo(value: self.initIsLocked())
+
+        let lastMask = OrientationDirectorUtils.getMaskFrom(jsOrientation: lastInterfaceOrientation)
+        let isLastMaskSupported = self.supportedInterfaceOrientations.contains(lastMask)
+        if (isLastMaskSupported) {
+            return
+        }
+
+        let supportedInterfaceOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        if (supportedInterfaceOrientations.contains(UIInterfaceOrientationMask.portrait)) {
+            self.updateLastInterfaceOrientationTo(value: Orientation.PORTRAIT)
+            return
+        }
+        if (supportedInterfaceOrientations.contains(UIInterfaceOrientationMask.landscapeRight)) {
+            self.updateLastInterfaceOrientationTo(value: Orientation.LANDSCAPE_RIGHT)
+            return
+        }
+        if (supportedInterfaceOrientations.contains(UIInterfaceOrientationMask.landscapeLeft)) {
+            self.updateLastInterfaceOrientationTo(value: Orientation.LANDSCAPE_LEFT)
+            return
+        }
+
+        self.updateLastInterfaceOrientationTo(value: Orientation.PORTRAIT_UPSIDE_DOWN)
     }
 
     private func initInitialSupportedInterfaceOrientations() -> UIInterfaceOrientationMask {
@@ -93,29 +118,25 @@ import UIKit
     private func requestInterfaceUpdateTo(mask: UIInterfaceOrientationMask) {
         self.supportedInterfaceOrientations = mask
 
-        DispatchQueue.main.async {
-            if #available(iOS 16.0, *) {
-                guard let window = OrientationDirectorUtils.getCurrentWindow() else {
-                    return
-                }
+        if #available(iOS 16.0, *) {
+            let window = OrientationDirectorUtils.getCurrentWindow()
 
-                guard let rootViewController = window.rootViewController else {
-                    return
-                }
+            guard let rootViewController = window?.rootViewController else {
+                return
+            }
 
-                guard let windowScene = window.windowScene else {
-                    return
-                }
+            guard let windowScene = window?.windowScene else {
+                return
+            }
 
-                rootViewController.setNeedsUpdateOfSupportedInterfaceOrientations()
+            rootViewController.setNeedsUpdateOfSupportedInterfaceOrientations()
 
-                windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: mask)) { error in
-                    print("\(OrientationDirectorImpl.TAG) - requestGeometryUpdate error", error)
-                }
-            } else {
-                UIDevice.current.setValue(mask.rawValue, forKey: "orientation")
-                UIViewController.attemptRotationToDeviceOrientation()
+            windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: mask)) { error in
+                print("\(OrientationDirectorImpl.TAG) - requestGeometryUpdate error", error)
             }
+        } else {
+            UIDevice.current.setValue(mask.rawValue, forKey: "orientation")
+            UIViewController.attemptRotationToDeviceOrientation()
         }
     }
 
@@ -128,23 +149,34 @@ import UIKit
 
     private func adaptInterfaceTo(deviceOrientation: Orientation) {
         if (isLocked) {
-          return
+            return
         }
-
-        if (lastInterfaceOrientation == deviceOrientation) {
-          return
+        
+        if (deviceOrientation == Orientation.FACE_UP || deviceOrientation == Orientation.FACE_DOWN) {
+            return
         }
 
-        if (deviceOrientation == Orientation.FACE_UP || deviceOrientation == Orientation.FACE_DOWN) {
-          return
+        let newInterfaceOrientationMask = OrientationDirectorUtils.getMaskFrom(deviceOrientation: deviceOrientation)
+        let isSupported = self.supportedInterfaceOrientations.contains(newInterfaceOrientationMask)
+        if (!isSupported) {
+            return
         }
 
-        self.eventManager.sendInterfaceOrientationDidChange(orientationValue: deviceOrientation.rawValue)
-        lastInterfaceOrientation = deviceOrientation
+        let newInterfaceOrientation = OrientationDirectorUtils.getOrientationFrom(mask: newInterfaceOrientationMask)
+        if (newInterfaceOrientation == lastInterfaceOrientation) {
+            return
+        }
+        
+        updateLastInterfaceOrientationTo(value: newInterfaceOrientation)
     }
 
     private func updateIsLockedTo(value: Bool) {
         eventManager.sendLockDidChange(value: value)
         isLocked = value
     }
+
+    private func updateLastInterfaceOrientationTo(value: Orientation) {
+        self.eventManager.sendInterfaceOrientationDidChange(orientationValue: value.rawValue)
+        lastInterfaceOrientation = value
+    }
 }

package/ios/implementation/OrientationDirectorUtils.swift

@@ -15,12 +15,12 @@ class OrientationDirectorUtils {
         var orientation = Orientation.UNKNOWN
 
         switch(uiInterfaceOrientation) {
-        case UIInterfaceOrientation.landscapeRight: // Home button on the right
-            orientation = Orientation.LANDSCAPE_LEFT
+        case UIInterfaceOrientation.landscapeRight:
+            orientation = Orientation.LANDSCAPE_RIGHT
         case UIInterfaceOrientation.portraitUpsideDown:
             orientation = Orientation.PORTRAIT_UPSIDE_DOWN
-        case UIInterfaceOrientation.landscapeLeft: // Home button on the left
-            orientation = Orientation.LANDSCAPE_RIGHT
+        case UIInterfaceOrientation.landscapeLeft:
+            orientation = Orientation.LANDSCAPE_LEFT
         default:
             orientation = Orientation.PORTRAIT
         }
@@ -65,26 +65,60 @@ class OrientationDirectorUtils {
 
         return orientation
     }
+    
+    public static func getOrientationFrom(mask: UIInterfaceOrientationMask) -> Orientation {
+        var orientation = Orientation.UNKNOWN
+        
+        switch(mask) {
+        case UIInterfaceOrientationMask.portraitUpsideDown:
+            orientation = Orientation.PORTRAIT_UPSIDE_DOWN
+        case UIInterfaceOrientationMask.landscapeRight:
+            orientation = Orientation.LANDSCAPE_RIGHT
+        case UIInterfaceOrientationMask.landscapeLeft:
+            orientation = Orientation.LANDSCAPE_LEFT
+        default:
+            orientation = Orientation.PORTRAIT
+        }
 
-    /*
-        Note: .portraitUpsideDown only works for devices with home button
-        //https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
-     */
-    public static func getMaskFrom(orientation: Orientation) -> UIInterfaceOrientationMask {
-        var mask = UIInterfaceOrientationMask.portrait
+        return orientation
+    }
 
-        switch(orientation) {
+    /**
+     Note: .portraitUpsideDown only works for devices with home button and iPads
+     https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
+     */
+    public static func getMaskFrom(jsOrientation: Orientation) -> UIInterfaceOrientationMask {
+        switch(jsOrientation) {
+        case Orientation.PORTRAIT:
+            return UIInterfaceOrientationMask.portrait
         case Orientation.LANDSCAPE_RIGHT:
-            mask = UIInterfaceOrientationMask.landscapeLeft
+            return UIInterfaceOrientationMask.landscapeRight
         case Orientation.PORTRAIT_UPSIDE_DOWN:
-            mask = UIInterfaceOrientationMask.portraitUpsideDown
+            return UIInterfaceOrientationMask.portraitUpsideDown
         case Orientation.LANDSCAPE_LEFT:
-            mask = UIInterfaceOrientationMask.landscapeRight
+            return UIInterfaceOrientationMask.landscapeLeft
         default:
-            mask = UIInterfaceOrientationMask.portrait
+            return UIInterfaceOrientationMask.all
+        }
+    }
+    
+    /**
+     Note: .portraitUpsideDown only works for devices with home button and iPads
+     https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
+     */
+    public static func getMaskFrom(deviceOrientation: Orientation) -> UIInterfaceOrientationMask {
+        switch(deviceOrientation) {
+        case Orientation.PORTRAIT:
+            return UIInterfaceOrientationMask.portrait
+        case Orientation.LANDSCAPE_RIGHT:
+            return UIInterfaceOrientationMask.landscapeLeft
+        case Orientation.PORTRAIT_UPSIDE_DOWN:
+            return UIInterfaceOrientationMask.portraitUpsideDown
+        case Orientation.LANDSCAPE_LEFT:
+            return UIInterfaceOrientationMask.landscapeRight
+        default:
+            return UIInterfaceOrientationMask.all
         }
-
-        return mask
     }
 
     public static func getInterfaceOrientation() -> UIInterfaceOrientation {

package/lib/commonjs/NativeOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeOrientationDirector.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAapCC,gCAAmB,CAACC,YAAY,CAAO,qBAAqB,CAAC","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeOrientationDirector.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAepCC,gCAAmB,CAACC,YAAY,CAAO,qBAAqB,CAAC","ignoreList":[]}

package/lib/commonjs/RNOrientationDirector.js

@@ -4,9 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _reactNative = require("react-native");
 var _module = _interopRequireWildcard(require("./module"));
 var _Event = _interopRequireDefault(require("./types/Event.enum"));
 var _Orientation = require("./types/Orientation.enum");
+var _AutoRotation = require("./types/AutoRotation.enum");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -38,6 +40,15 @@ class RNOrientationDirector {
   static isLocked() {
     return _module.default.isLocked();
   }
+  static isAutoRotationEnabled() {
+    if (_reactNative.Platform.OS !== 'android') {
+      return _AutoRotation.AutoRotation.unknown;
+    }
+    return _module.default.isAutoRotationEnabled() ? _AutoRotation.AutoRotation.enabled : _AutoRotation.AutoRotation.disabled;
+  }
+  static resetSupportedInterfaceOrientations() {
+    _module.default.resetSupportedInterfaceOrientations();
+  }
   static listenForDeviceOrientationChanges(callback) {
     return _module.EventEmitter.addListener(_Event.default.DeviceOrientationDidChange, callback);
   }

package/lib/commonjs/RNOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["_module","_interopRequireWildcard","require","_Event","_interopRequireDefault","_Orientation","obj","__esModule","default","_getRequireWildcardCache","e","WeakMap","r","t","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","RNOrientationDirector","_localizedStringProvider","Orientation","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","Module","getDeviceOrientation","lockTo","orientation","unlock","isLocked","listenForDeviceOrientationChanges","callback","EventEmitter","addListener","Event","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","listenForLockChanges","LockDidChange","convertOrientationToHumanReadableString","_default","exports"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","_module","_interopRequireWildcard","_Event","_interopRequireDefault","_Orientation","_AutoRotation","obj","__esModule","default","_getRequireWildcardCache","e","WeakMap","r","t","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","RNOrientationDirector","_localizedStringProvider","Orientation","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","Module","getDeviceOrientation","lockTo","orientation","unlock","isLocked","isAutoRotationEnabled","Platform","OS","AutoRotation","enabled","disabled","resetSupportedInterfaceOrientations","listenForDeviceOrientationChanges","callback","EventEmitter","addListener","Event","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","listenForLockChanges","LockDidChange","convertOrientationToHumanReadableString","_default","exports"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "AutoRotation", {
+  enumerable: true,
+  get: function () {
+    return _AutoRotation.AutoRotation;
+  }
+});
 Object.defineProperty(exports, "Orientation", {
   enumerable: true,
   get: function () {
@@ -29,6 +35,7 @@ Object.defineProperty(exports, "useIsInterfaceOrientationLocked", {
   }
 });
 var _Orientation = require("./types/Orientation.enum");
+var _AutoRotation = require("./types/AutoRotation.enum");
 var _useDeviceOrientation = _interopRequireDefault(require("./hooks/useDeviceOrientation.hook"));
 var _useInterfaceOrientation = _interopRequireDefault(require("./hooks/useInterfaceOrientation.hook"));
 var _useIsInterfaceOrientationLocked = _interopRequireDefault(require("./hooks/useIsInterfaceOrientationLocked.hook"));

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_Orientation","require","_useDeviceOrientation","_interopRequireDefault","_useInterfaceOrientation","_useIsInterfaceOrientationLocked","_RNOrientationDirector","obj","__esModule","default","_default","exports","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,IAAAC,qBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAGA,IAAAG,wBAAA,GAAAD,sBAAA,CAAAF,OAAA;AAGA,IAAAI,gCAAA,GAAAF,sBAAA,CAAAF,OAAA;AAGA,IAAAK,sBAAA,GAAAH,sBAAA,CAAAF,OAAA;AAA4D,SAAAE,uBAAAI,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAC7CG,8BAAqB","ignoreList":[]}
+{"version":3,"names":["_Orientation","require","_AutoRotation","_useDeviceOrientation","_interopRequireDefault","_useInterfaceOrientation","_useIsInterfaceOrientationLocked","_RNOrientationDirector","obj","__esModule","default","_default","exports","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA;AAEA,IAAAE,qBAAA,GAAAC,sBAAA,CAAAH,OAAA;AAGA,IAAAI,wBAAA,GAAAD,sBAAA,CAAAH,OAAA;AAGA,IAAAK,gCAAA,GAAAF,sBAAA,CAAAH,OAAA;AAGA,IAAAM,sBAAA,GAAAH,sBAAA,CAAAH,OAAA;AAA4D,SAAAG,uBAAAI,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAC7CG,8BAAqB","ignoreList":[]}

package/lib/commonjs/types/AutoRotation.enum.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AutoRotation = void 0;
+let AutoRotation = exports.AutoRotation = /*#__PURE__*/function (AutoRotation) {
+  AutoRotation[AutoRotation["unknown"] = 0] = "unknown";
+  AutoRotation[AutoRotation["enabled"] = 1] = "enabled";
+  AutoRotation[AutoRotation["disabled"] = 2] = "disabled";
+  return AutoRotation;
+}({});
+//# sourceMappingURL=AutoRotation.enum.js.map

package/lib/commonjs/types/AutoRotation.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AutoRotation","exports"],"sourceRoot":"../../../src","sources":["types/AutoRotation.enum.ts"],"mappings":";;;;;;IAAYA,YAAY,GAAAC,OAAA,CAAAD,YAAA,0BAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA","ignoreList":[]}

package/lib/module/NativeOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeOrientationDirector.ts"],"mappings":"AACA,SAASA,mBAAmB,QAAQ,cAAc;AAalD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,qBAAqB,CAAC","ignoreList":[]}
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeOrientationDirector.ts"],"mappings":"AACA,SAASA,mBAAmB,QAAQ,cAAc;AAelD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,qBAAqB,CAAC","ignoreList":[]}

package/lib/module/RNOrientationDirector.js

@@ -1,6 +1,8 @@
+import { Platform } from 'react-native';
 import Module, { EventEmitter } from './module';
 import Event from './types/Event.enum';
 import { Orientation } from './types/Orientation.enum';
+import { AutoRotation } from './types/AutoRotation.enum';
 class RNOrientationDirector {
   static _localizedStringProvider = {
     [Orientation.unknown]: 'Unknown',
@@ -29,6 +31,15 @@ class RNOrientationDirector {
   static isLocked() {
     return Module.isLocked();
   }
+  static isAutoRotationEnabled() {
+    if (Platform.OS !== 'android') {
+      return AutoRotation.unknown;
+    }
+    return Module.isAutoRotationEnabled() ? AutoRotation.enabled : AutoRotation.disabled;
+  }
+  static resetSupportedInterfaceOrientations() {
+    Module.resetSupportedInterfaceOrientations();
+  }
   static listenForDeviceOrientationChanges(callback) {
     return EventEmitter.addListener(Event.DeviceOrientationDidChange, callback);
   }

package/lib/module/RNOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["Module","EventEmitter","Event","Orientation","RNOrientationDirector","_localizedStringProvider","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","getDeviceOrientation","lockTo","orientation","unlock","isLocked","listenForDeviceOrientationChanges","callback","addListener","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","listenForLockChanges","LockDidChange","convertOrientationToHumanReadableString"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"AAAA,OAAOA,MAAM,IAAIC,YAAY,QAAQ,UAAU;AAC/C,OAAOC,KAAK,MAAM,oBAAoB;AAEtC,SAASC,WAAW,QAAQ,0BAA0B;AAKtD,MAAMC,qBAAqB,CAAC;EAC1B,OAAeC,wBAAwB,GACrC;IACE,CAACF,WAAW,CAACG,OAAO,GAAG,SAAS;IAChC,CAACH,WAAW,CAACI,QAAQ,GAAG,UAAU;IAClC,CAACJ,WAAW,CAACK,kBAAkB,GAAG,sBAAsB;IACxD,CAACL,WAAW,CAACM,aAAa,GAAG,gBAAgB;IAC7C,CAACN,WAAW,CAACO,cAAc,GAAG,iBAAiB;IAC/C,CAACP,WAAW,CAACQ,MAAM,GAAG,SAAS;IAC/B,CAACR,WAAW,CAACS,QAAQ,GAAG;EAC1B,CAAC;EAEHC,0BAA0BA,CACxBC,QAAuD,EACvD;IACAV,qBAAqB,CAACC,wBAAwB,GAAGS,QAAQ;EAC3D;EAEA,OAAOC,uBAAuBA,CAAA,EAAyB;IACrD,OAAOf,MAAM,CAACe,uBAAuB,CAAC,CAAC;EACzC;EAEA,OAAOC,oBAAoBA,CAAA,EAAyB;IAClD,OAAOhB,MAAM,CAACgB,oBAAoB,CAAC,CAAC;EACtC;EAEA,OAAOC,MAAMA,CAACC,WAAgC,EAAE;IAC9ClB,MAAM,CAACiB,MAAM,CAACC,WAAW,CAAC;EAC5B;EAEA,OAAOC,MAAMA,CAAA,EAAG;IACdnB,MAAM,CAACmB,MAAM,CAAC,CAAC;EACjB;EAEA,OAAOC,QAAQA,CAAA,EAAG;IAChB,OAAOpB,MAAM,CAACoB,QAAQ,CAAC,CAAC;EAC1B;EAEA,OAAOC,iCAAiCA,CACtCC,QAAiD,EACjD;IACA,OAAOrB,YAAY,CAACsB,WAAW,CAACrB,KAAK,CAACsB,0BAA0B,EAAEF,QAAQ,CAAC;EAC7E;EAEA,OAAOG,oCAAoCA,CACzCH,QAAiD,EACjD;IACA,OAAOrB,YAAY,CAACsB,WAAW,CAC7BrB,KAAK,CAACwB,6BAA6B,EACnCJ,QACF,CAAC;EACH;EAEA,OAAOK,oBAAoBA,CAACL,QAA4C,EAAE;IACxE,OAAOrB,YAAY,CAACsB,WAAW,CAACrB,KAAK,CAAC0B,aAAa,EAAEN,QAAQ,CAAC;EAChE;EAEA,OAAOO,uCAAuCA,CAC5CX,WAAwB,EAChB;IACR,OAAOd,qBAAqB,CAACC,wBAAwB,CAACa,WAAW,CAAC;EACpE;AACF;AAEA,eAAed,qBAAqB","ignoreList":[]}
+{"version":3,"names":["Platform","Module","EventEmitter","Event","Orientation","AutoRotation","RNOrientationDirector","_localizedStringProvider","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","getDeviceOrientation","lockTo","orientation","unlock","isLocked","isAutoRotationEnabled","OS","enabled","disabled","resetSupportedInterfaceOrientations","listenForDeviceOrientationChanges","callback","addListener","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","listenForLockChanges","LockDidChange","convertOrientationToHumanReadableString"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,cAAc;AACvC,OAAOC,MAAM,IAAIC,YAAY,QAAQ,UAAU;AAC/C,OAAOC,KAAK,MAAM,oBAAoB;AAEtC,SAASC,WAAW,QAAQ,0BAA0B;AACtD,SAASC,YAAY,QAAQ,2BAA2B;AAKxD,MAAMC,qBAAqB,CAAC;EAC1B,OAAeC,wBAAwB,GACrC;IACE,CAACH,WAAW,CAACI,OAAO,GAAG,SAAS;IAChC,CAACJ,WAAW,CAACK,QAAQ,GAAG,UAAU;IAClC,CAACL,WAAW,CAACM,kBAAkB,GAAG,sBAAsB;IACxD,CAACN,WAAW,CAACO,aAAa,GAAG,gBAAgB;IAC7C,CAACP,WAAW,CAACQ,cAAc,GAAG,iBAAiB;IAC/C,CAACR,WAAW,CAACS,MAAM,GAAG,SAAS;IAC/B,CAACT,WAAW,CAACU,QAAQ,GAAG;EAC1B,CAAC;EAEHC,0BAA0BA,CACxBC,QAAuD,EACvD;IACAV,qBAAqB,CAACC,wBAAwB,GAAGS,QAAQ;EAC3D;EAEA,OAAOC,uBAAuBA,CAAA,EAAyB;IACrD,OAAOhB,MAAM,CAACgB,uBAAuB,CAAC,CAAC;EACzC;EAEA,OAAOC,oBAAoBA,CAAA,EAAyB;IAClD,OAAOjB,MAAM,CAACiB,oBAAoB,CAAC,CAAC;EACtC;EAEA,OAAOC,MAAMA,CAACC,WAAgC,EAAE;IAC9CnB,MAAM,CAACkB,MAAM,CAACC,WAAW,CAAC;EAC5B;EAEA,OAAOC,MAAMA,CAAA,EAAG;IACdpB,MAAM,CAACoB,MAAM,CAAC,CAAC;EACjB;EAEA,OAAOC,QAAQA,CAAA,EAAG;IAChB,OAAOrB,MAAM,CAACqB,QAAQ,CAAC,CAAC;EAC1B;EAEA,OAAOC,qBAAqBA,CAAA,EAAiB;IAC3C,IAAIvB,QAAQ,CAACwB,EAAE,KAAK,SAAS,EAAE;MAC7B,OAAOnB,YAAY,CAACG,OAAO;IAC7B;IACA,OAAOP,MAAM,CAACsB,qBAAqB,CAAC,CAAC,GACjClB,YAAY,CAACoB,OAAO,GACpBpB,YAAY,CAACqB,QAAQ;EAC3B;EAEA,OAAOC,mCAAmCA,CAAA,EAAS;IACjD1B,MAAM,CAAC0B,mCAAmC,CAAC,CAAC;EAC9C;EAEA,OAAOC,iCAAiCA,CACtCC,QAAiD,EACjD;IACA,OAAO3B,YAAY,CAAC4B,WAAW,CAAC3B,KAAK,CAAC4B,0BAA0B,EAAEF,QAAQ,CAAC;EAC7E;EAEA,OAAOG,oCAAoCA,CACzCH,QAAiD,EACjD;IACA,OAAO3B,YAAY,CAAC4B,WAAW,CAC7B3B,KAAK,CAAC8B,6BAA6B,EACnCJ,QACF,CAAC;EACH;EAEA,OAAOK,oBAAoBA,CAACL,QAA4C,EAAE;IACxE,OAAO3B,YAAY,CAAC4B,WAAW,CAAC3B,KAAK,CAACgC,aAAa,EAAEN,QAAQ,CAAC;EAChE;EAEA,OAAOO,uCAAuCA,CAC5ChB,WAAwB,EAChB;IACR,OAAOd,qBAAqB,CAACC,wBAAwB,CAACa,WAAW,CAAC;EACpE;AACF;AAEA,eAAed,qBAAqB","ignoreList":[]}

package/lib/module/index.js

@@ -1,4 +1,5 @@
 export { Orientation } from './types/Orientation.enum';
+export { AutoRotation } from './types/AutoRotation.enum';
 import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };
 import useInterfaceOrientation from './hooks/useInterfaceOrientation.hook';

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["Orientation","useDeviceOrientation","useInterfaceOrientation","useIsInterfaceOrientationLocked","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0BAA0B;AAEtD,OAAOC,oBAAoB,MAAM,mCAAmC;AACpE,SAASA,oBAAoB;AAE7B,OAAOC,uBAAuB,MAAM,sCAAsC;AAC1E,SAASA,uBAAuB;AAEhC,OAAOC,+BAA+B,MAAM,8CAA8C;AAC1F,SAASA,+BAA+B;AAExC,OAAOC,qBAAqB,MAAM,yBAAyB;AAC3D,eAAeA,qBAAqB","ignoreList":[]}
+{"version":3,"names":["Orientation","AutoRotation","useDeviceOrientation","useInterfaceOrientation","useIsInterfaceOrientationLocked","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0BAA0B;AACtD,SAASC,YAAY,QAAQ,2BAA2B;AAExD,OAAOC,oBAAoB,MAAM,mCAAmC;AACpE,SAASA,oBAAoB;AAE7B,OAAOC,uBAAuB,MAAM,sCAAsC;AAC1E,SAASA,uBAAuB;AAEhC,OAAOC,+BAA+B,MAAM,8CAA8C;AAC1F,SAASA,+BAA+B;AAExC,OAAOC,qBAAqB,MAAM,yBAAyB;AAC3D,eAAeA,qBAAqB","ignoreList":[]}

package/lib/module/types/AutoRotation.enum.js

@@ -0,0 +1,7 @@
+export let AutoRotation = /*#__PURE__*/function (AutoRotation) {
+  AutoRotation[AutoRotation["unknown"] = 0] = "unknown";
+  AutoRotation[AutoRotation["enabled"] = 1] = "enabled";
+  AutoRotation[AutoRotation["disabled"] = 2] = "disabled";
+  return AutoRotation;
+}({});
+//# sourceMappingURL=AutoRotation.enum.js.map

package/lib/module/types/AutoRotation.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AutoRotation"],"sourceRoot":"../../../src","sources":["types/AutoRotation.enum.ts"],"mappings":"AAAA,WAAYA,YAAY,0BAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA","ignoreList":[]}

package/lib/typescript/src/NativeOrientationDirector.d.ts

@@ -5,6 +5,8 @@ export interface Spec extends TurboModule {
     lockTo(orientation: number): void;
     unlock(): void;
     isLocked(): boolean;
+    isAutoRotationEnabled(): boolean;
+    resetSupportedInterfaceOrientations(): void;
     addListener: (eventType: string) => void;
     removeListeners: (count: number) => void;
 }

package/lib/typescript/src/NativeOrientationDirector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/NativeOrientationDirector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,uBAAuB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,MAAM,IAAI,IAAI,CAAC;IACf,QAAQ,IAAI,OAAO,CAAC;IAEpB,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;;AAED,wBAA6E"}
+{"version":3,"file":"NativeOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/NativeOrientationDirector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,uBAAuB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,MAAM,IAAI,IAAI,CAAC;IACf,QAAQ,IAAI,OAAO,CAAC;IACpB,qBAAqB,IAAI,OAAO,CAAC;IACjC,mCAAmC,IAAI,IAAI,CAAC;IAE5C,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;;AAED,wBAA6E"}

package/lib/typescript/src/RNOrientationDirector.d.ts

@@ -1,5 +1,6 @@
 import type { InterfaceOrientationToLocalizedStringProvider } from './types/InterfaceOrientationToLocalizedStringProvider.type';
 import { Orientation } from './types/Orientation.enum';
+import { AutoRotation } from './types/AutoRotation.enum';
 import type { OrientationEvent } from './types/OrientationEvent.interface';
 import type { LockableOrientation } from './types/LockableOrientation.type';
 import type { LockedEvent } from './types/LockedEvent.interface';
@@ -11,6 +12,8 @@ declare class RNOrientationDirector {
     static lockTo(orientation: LockableOrientation): void;
     static unlock(): void;
     static isLocked(): boolean;
+    static isAutoRotationEnabled(): AutoRotation;
+    static resetSupportedInterfaceOrientations(): void;
     static listenForDeviceOrientationChanges(callback: (orientation: OrientationEvent) => void): import("react-native").EmitterSubscription;
     static listenForInterfaceOrientationChanges(callback: (orientation: OrientationEvent) => void): import("react-native").EmitterSubscription;
     static listenForLockChanges(callback: (orientation: LockedEvent) => void): import("react-native").EmitterSubscription;

package/lib/typescript/src/RNOrientationDirector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RNOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/RNOrientationDirector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6CAA6C,EAAE,MAAM,4DAA4D,CAAC;AAChI,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,cAAM,qBAAqB;IACzB,OAAO,CAAC,MAAM,CAAC,wBAAwB,CASnC;IAEJ,0BAA0B,CACxB,QAAQ,EAAE,6CAA6C;IAKzD,MAAM,CAAC,uBAAuB,IAAI,OAAO,CAAC,WAAW,CAAC;IAItD,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IAInD,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,mBAAmB;IAI9C,MAAM,CAAC,MAAM;IAIb,MAAM,CAAC,QAAQ;IAIf,MAAM,CAAC,iCAAiC,CACtC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAKnD,MAAM,CAAC,oCAAoC,CACzC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAQnD,MAAM,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI;IAIxE,MAAM,CAAC,uCAAuC,CAC5C,WAAW,EAAE,WAAW,GACvB,MAAM;CAGV;AAED,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"RNOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/RNOrientationDirector.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,6CAA6C,EAAE,MAAM,4DAA4D,CAAC;AAChI,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,cAAM,qBAAqB;IACzB,OAAO,CAAC,MAAM,CAAC,wBAAwB,CASnC;IAEJ,0BAA0B,CACxB,QAAQ,EAAE,6CAA6C;IAKzD,MAAM,CAAC,uBAAuB,IAAI,OAAO,CAAC,WAAW,CAAC;IAItD,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IAInD,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,mBAAmB;IAI9C,MAAM,CAAC,MAAM;IAIb,MAAM,CAAC,QAAQ;IAIf,MAAM,CAAC,qBAAqB,IAAI,YAAY;IAS5C,MAAM,CAAC,mCAAmC,IAAI,IAAI;IAIlD,MAAM,CAAC,iCAAiC,CACtC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAKnD,MAAM,CAAC,oCAAoC,CACzC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAQnD,MAAM,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI;IAIxE,MAAM,CAAC,uCAAuC,CAC5C,WAAW,EAAE,WAAW,GACvB,MAAM;CAGV;AAED,eAAe,qBAAqB,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -1,4 +1,5 @@
 export { Orientation } from './types/Orientation.enum';
+export { AutoRotation } from './types/AutoRotation.enum';
 import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };
 import useInterfaceOrientation from './hooks/useInterfaceOrientation.hook';

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,oBAAoB,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAEhC,OAAO,uBAAuB,MAAM,sCAAsC,CAAC;AAC3E,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,OAAO,+BAA+B,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EAAE,+BAA+B,EAAE,CAAC;AAE3C,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,oBAAoB,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAEhC,OAAO,uBAAuB,MAAM,sCAAsC,CAAC;AAC3E,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,OAAO,+BAA+B,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EAAE,+BAA+B,EAAE,CAAC;AAE3C,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,eAAe,qBAAqB,CAAC"}

package/lib/typescript/src/types/AutoRotation.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum AutoRotation {
+    unknown = 0,
+    enabled = 1,
+    disabled = 2
+}
+//# sourceMappingURL=AutoRotation.enum.d.ts.map

package/lib/typescript/src/types/AutoRotation.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoRotation.enum.d.ts","sourceRoot":"","sources":["../../../../src/types/AutoRotation.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY;IACtB,OAAO,IAAI;IACX,OAAO,IAAI;IACX,QAAQ,IAAI;CACb"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-orientation-director",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "A Modern React Native library that allows you to access orientation",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/NativeOrientationDirector.ts

@@ -7,6 +7,8 @@ export interface Spec extends TurboModule {
   lockTo(orientation: number): void;
   unlock(): void;
   isLocked(): boolean;
+  isAutoRotationEnabled(): boolean;
+  resetSupportedInterfaceOrientations(): void;
 
   addListener: (eventType: string) => void;
   removeListeners: (count: number) => void;

package/src/RNOrientationDirector.ts

@@ -1,7 +1,9 @@
+import { Platform } from 'react-native';
 import Module, { EventEmitter } from './module';
 import Event from './types/Event.enum';
 import type { InterfaceOrientationToLocalizedStringProvider } from './types/InterfaceOrientationToLocalizedStringProvider.type';
 import { Orientation } from './types/Orientation.enum';
+import { AutoRotation } from './types/AutoRotation.enum';
 import type { OrientationEvent } from './types/OrientationEvent.interface';
 import type { LockableOrientation } from './types/LockableOrientation.type';
 import type { LockedEvent } from './types/LockedEvent.interface';
@@ -44,6 +46,19 @@ class RNOrientationDirector {
     return Module.isLocked();
   }
 
+  static isAutoRotationEnabled(): AutoRotation {
+    if (Platform.OS !== 'android') {
+      return AutoRotation.unknown;
+    }
+    return Module.isAutoRotationEnabled()
+      ? AutoRotation.enabled
+      : AutoRotation.disabled;
+  }
+
+  static resetSupportedInterfaceOrientations(): void {
+    Module.resetSupportedInterfaceOrientations();
+  }
+
   static listenForDeviceOrientationChanges(
     callback: (orientation: OrientationEvent) => void
   ) {

package/src/index.tsx

@@ -1,4 +1,5 @@
 export { Orientation } from './types/Orientation.enum';
+export { AutoRotation } from './types/AutoRotation.enum';
 
 import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };

package/src/types/AutoRotation.enum.ts

@@ -0,0 +1,5 @@
+export enum AutoRotation {
+  unknown = 0,
+  enabled = 1,
+  disabled = 2,
+}