react-native-orientation-director 1.0.1 → 1.2.0

package/README.md

@@ -1,14 +1,25 @@
+![NPM Version](https://img.shields.io/npm/v/react-native-orientation-director)
+
+---
+
 # react-native-orientation-director
 
 A simple library that allows you to handle orientation changes in your React Native app.
 Written in Kotlin, Swift and Typescript. It supports both the Old and New React Native architecture.
 
+This library takes inspiration from and builds upon the following amazing alternatives:
+
+1. [react-native-orientation-locker](https://github.com/wonday/react-native-orientation-locker)
+2. [react-native-orientation-handler](https://github.com/KroosX4V/react-native-orientation-manager)
+
 ## Features
 
 - [x] Get the current orientation of the device
 - [x] Get the current orientation of the interface
+- [x] Get the current interface orientation status (locked or unlocked)
 - [x] Listen to device orientation changes
 - [x] Listen to interface orientation changes
+- [x] Listen to interface orientation status changes
 - [x] Lock the interface orientation to a specific orientation
 - [x] Unlock the interface orientation
 
@@ -23,7 +34,7 @@ npm install react-native-orientation-director
 yarn add react-native-orientation-director
 ```
 
-Don't forget to run pod-install
+Don't forget to run pod-install.
 
 ## Setup
 
@@ -53,17 +64,20 @@ This library exports a class called: [RNOrientationDirector](https://github.com/
 | getDeviceOrientation                    | Returns the last device orientation                                             |
 | lockTo                                  | Locks the interface to a specific orientation                                   |
 | unlock                                  | Unlock the interface                                                            |
+| isLocked                                | Returns the current interface orientation status (locked / unlocked)            |
 | listenForDeviceOrientationChanges       | Triggers a provided callback each time the device orientation changes           |
 | listenForInterfaceOrientationChanges    | Triggers a provided callback each time the interface orientation changes        |
+| listenForLockChanges                    | Triggers a provided callback each time the interface orientation status changes |
 | convertOrientationToHumanReadableString | Returns a human readable string based on the given orientation                  |
 | setLocalizedStringProvider              | Sets the mapping needed to convert orientation values to human readable strings |
 
 In addition, the library exposes the following hooks:
 
-| Hook                                                                                                                                            | Description                                                      |
-|-------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------|
-| [useInterfaceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useInterfaceOrientation.hook.ts) | Returns the current interface orientation and listens to changes |
-| [useDeviceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useDeviceOrientation.hook.ts)       | Returns the current device orientation and listens to changes    |
+| Hook                                                                                                                                                            | Description                                                             |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
+| [useInterfaceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useInterfaceOrientation.hook.ts)                 | Returns the current interface orientation and listens to changes        |
+| [useDeviceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useDeviceOrientation.hook.ts)                       | Returns the current device orientation and listens to changes           |
+| [useIsInterfaceOrientationLocked](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useIsInterfaceOrientationLocked.hook.ts) | Returns the current interface orientation status and listens to changes |
 
 Head over to the [example project](example) to see how to use the library.
 
@@ -78,10 +92,6 @@ Head over to the [example project](example) to see how to use the library.
 
 See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
 
-## License
-
-MIT
-
 ---
 
 Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

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

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

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,17 +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()
+  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 isLocked: Boolean = false
+
+  private var initialSupportedInterfaceOrientations = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
   private var lastInterfaceOrientation = Orientation.UNKNOWN
   private var lastDeviceOrientation = Orientation.UNKNOWN
   private var initialized = false
+  private var isLocked: Boolean = false
 
   init {
     mSensorListener.setOnOrientationChangedCallback { orientation ->
@@ -24,23 +33,32 @@ 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 =
+      context.currentActivity?.requestedOrientation ?: initialSupportedInterfaceOrientations
     lastInterfaceOrientation = initInterfaceOrientation()
     lastDeviceOrientation = initDeviceOrientation()
+    isLocked = initIsLocked()
 
     initialized = true
   }
@@ -53,35 +71,39 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     return lastDeviceOrientation
   }
 
+  fun getIsLocked(): Boolean {
+    return isLocked
+  }
+
+  fun getIsAutoRotationEnabled(): Boolean {
+    return mAutoRotationObserver.getLastAutoRotationStatus()
+  }
+
   fun lockTo(jsOrientation: Int) {
-    val interfaceOrientation = mUtils.getOrientationEnumFrom(jsOrientation)
+    val interfaceOrientation = mUtils.getOrientationFromJsOrientation(jsOrientation)
     val screenOrientation =
       mUtils.getActivityOrientationFrom(interfaceOrientation)
     context.currentActivity?.requestedOrientation = screenOrientation
     mEventEmitter.sendInterfaceOrientationDidChange(interfaceOrientation.ordinal)
     lastInterfaceOrientation = interfaceOrientation
-    isLocked = true
+    updateIsLockedTo(true)
   }
 
   fun unlock() {
     context.currentActivity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
-    isLocked = false
+    updateIsLockedTo(false)
     adaptInterfaceTo(getDeviceOrientation())
   }
 
-  private fun initInterfaceOrientation(): Orientation {
-    val activityOrientation = context.currentActivity!!.requestedOrientation
-    if (
-      mUtils.isActivityInPortraitOrientation(activityOrientation) ||
-      mUtils.isActivityInLandscapeOrientation(activityOrientation)
-    ) {
-      return mUtils.getInterfaceOrientationFrom(activityOrientation)
-    }
-
-    val lastRotationDetected = mSensorListener.getLastRotationDetected()
-      ?: return lastInterfaceOrientation
+  fun resetSupportedInterfaceOrientations() {
+    context.currentActivity?.requestedOrientation = initialSupportedInterfaceOrientations
+    updateIsLockedTo(initIsLocked())
+    updateLastInterfaceOrientationTo(initInterfaceOrientation())
+  }
 
-    return mUtils.getDeviceOrientationFrom(lastRotationDetected)
+  private fun initInterfaceOrientation(): Orientation {
+    val rotation = mUtils.getInterfaceRotation()
+    return mUtils.getOrientationFromRotation(rotation)
   }
 
   private fun initDeviceOrientation(): Orientation {
@@ -91,6 +113,17 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     return mUtils.getDeviceOrientationFrom(lastRotationDetected)
   }
 
+  private fun initIsLocked(): Boolean {
+    val activity = context.currentActivity ?: return false
+    return listOf(
+      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
+      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
+      ActivityInfo.SCREEN_ORIENTATION_LOCKED,
+    ).contains(activity.requestedOrientation)
+  }
+
   private fun onOrientationChanged(rawDeviceOrientation: Int) {
     val deviceOrientation = mUtils.getDeviceOrientationFrom(rawDeviceOrientation)
     mEventEmitter.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
@@ -99,6 +132,10 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
   }
 
   private fun adaptInterfaceTo(deviceOrientation: Orientation) {
+    if (!mAutoRotationObserver.getLastAutoRotationStatus()) {
+      return
+    }
+
     if (isLocked) {
       return
     }
@@ -107,8 +144,17 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
       return
     }
 
-    lastInterfaceOrientation = deviceOrientation
-    mEventEmitter.sendInterfaceOrientationDidChange(lastInterfaceOrientation.ordinal)
+    updateLastInterfaceOrientationTo(deviceOrientation)
+  }
+
+  private fun updateIsLockedTo(value: Boolean) {
+    mEventEmitter.sendLockDidChange(value)
+    isLocked = value
+  }
+
+  private fun updateLastInterfaceOrientationTo(value: Orientation) {
+    lastInterfaceOrientation = value
+    mEventEmitter.sendInterfaceOrientationDidChange(value.ordinal)
   }
 
   companion object {

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

@@ -1,8 +1,24 @@
 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
 
-class OrientationDirectorUtilsImpl() {
+class OrientationDirectorUtilsImpl(val context: ReactContext) {
+
+  fun getInterfaceRotation(): Int {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      context.currentActivity?.display?.rotation ?: Surface.ROTATION_0
+    } else {
+      val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+      @Suppress("DEPRECATION")
+      windowManager.defaultDisplay.rotation
+    }
+  }
 
   fun getDeviceOrientationFrom(rotation: Int): Orientation {
     var orientation = Orientation.UNKNOWN
@@ -22,29 +38,6 @@ class OrientationDirectorUtilsImpl() {
     return orientation
   }
 
-  fun getInterfaceOrientationFrom(activityInfo: Int): Orientation {
-    return when (activityInfo) {
-      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE -> Orientation.LANDSCAPE_RIGHT
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT -> Orientation.PORTRAIT_UPSIDE_DOWN
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE -> Orientation.LANDSCAPE_LEFT
-      else -> Orientation.PORTRAIT
-    };
-  }
-
-  fun isActivityInLandscapeOrientation(orientation: Int): Boolean {
-    return listOf(
-      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
-    ).contains(orientation);
-  }
-
-  fun isActivityInPortraitOrientation(orientation: Int): Boolean {
-    return listOf(
-      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
-    ).contains(orientation);
-  }
-
   fun getActivityOrientationFrom(interfaceOrientation: Orientation): Int {
     return when (interfaceOrientation) {
       Orientation.LANDSCAPE_RIGHT -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
@@ -54,7 +47,7 @@ class OrientationDirectorUtilsImpl() {
     }
   }
 
-  fun getOrientationEnumFrom(jsOrientation: Int): Orientation {
+  fun getOrientationFromJsOrientation(jsOrientation: Int): Orientation {
     return when (jsOrientation) {
       2 -> Orientation.LANDSCAPE_RIGHT
       3 -> Orientation.PORTRAIT_UPSIDE_DOWN
@@ -62,4 +55,13 @@ class OrientationDirectorUtilsImpl() {
       else -> Orientation.PORTRAIT
     }
   }
+
+  fun getOrientationFromRotation(rotation: Int): Orientation {
+    return when(rotation) {
+      Surface.ROTATION_270 -> Orientation.LANDSCAPE_RIGHT
+      Surface.ROTATION_90 -> Orientation.LANDSCAPE_LEFT
+      Surface.ROTATION_180 -> Orientation.PORTRAIT_UPSIDE_DOWN
+      else -> Orientation.PORTRAIT
+    }
+  }
 }

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

@@ -9,6 +9,7 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 enum class Event {
   DeviceOrientationDidChange,
   InterfaceOrientationDidChange,
+  LockDidChange,
 }
 
 class OrientationEventManager(private val context: ReactApplicationContext) {
@@ -27,6 +28,13 @@ class OrientationEventManager(private val context: ReactApplicationContext) {
     sendEvent(Event.InterfaceOrientationDidChange, params)
   }
 
+  fun sendLockDidChange(value: Boolean) {
+    val params = Arguments.createMap().apply {
+      putBoolean("locked", value)
+    }
+    sendEvent(Event.LockDidChange, params)
+  }
+
   private fun sendEvent(eventName: Event, params: WritableMap?) {
     Log.d(NAME, "sendEvent - $eventName")
     Log.d(NAME, "sendEvent - $params")

package/android/src/oldarch/OrientationDirectorSpec.kt

@@ -6,11 +6,13 @@ import com.facebook.react.bridge.Promise
 
 abstract class OrientationDirectorSpec internal constructor(context: ReactApplicationContext) :
   ReactContextBaseJavaModule(context) {
-
   abstract fun getInterfaceOrientation(promise: Promise)
   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

@@ -64,7 +64,7 @@ RCT_EXPORT_MODULE()
 
 + (UIInterfaceOrientationMask)getSupportedInterfaceOrientationsForWindow
 {
-    return [_director supportedInterfaceOrientation];
+    return [_director supportedInterfaceOrientations];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -114,6 +114,27 @@ RCT_EXPORT_METHOD(unlock)
     });
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (NSNumber *)isLocked
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isLocked)
+#endif
+{
+    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

@@ -12,19 +12,24 @@ import UIKit
     private static let TAG = "OrientationDirectorImpl"
     private let sensorListener: OrientationSensorListener
     private let eventManager: OrientationEventManager
-    private var isLocked: Bool = false
-    private var lastInterfaceOrientation: Orientation = Orientation.UNKNOWN
-    private var lastDeviceOrientation: Orientation = Orientation.UNKNOWN
+    private var initialSupportedInterfaceOrientations: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
+    private var lastInterfaceOrientation = Orientation.UNKNOWN
+    private var lastDeviceOrientation = Orientation.UNKNOWN
 
-    @objc public var supportedInterfaceOrientation: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
+    @objc public var supportedInterfaceOrientations: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
+    @objc public var isLocked = false
 
     @objc public override init() {
         eventManager = OrientationEventManager()
         sensorListener = OrientationSensorListener()
         super.init()
         sensorListener.setOnOrientationChanged(callback: self.onOrientationChanged)
+        initialSupportedInterfaceOrientations = initInitialSupportedInterfaceOrientations()
         lastInterfaceOrientation = initInterfaceOrientation()
         lastDeviceOrientation = initDeviceOrientation()
+        isLocked = initIsLocked()
+
+        supportedInterfaceOrientations = initialSupportedInterfaceOrientations
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////
@@ -51,17 +56,50 @@ import UIKit
 
         eventManager.sendInterfaceOrientationDidChange(orientationValue: orientation.rawValue)
         lastInterfaceOrientation = orientation
-        isLocked = true
+        updateIsLockedTo(value: true)
     }
 
     @objc public func unlock() {
         self.requestInterfaceUpdateTo(mask: UIInterfaceOrientationMask.all)
 
         let deviceOrientation = OrientationDirectorUtils.getOrientationFrom(deviceOrientation: UIDevice.current.orientation)
-        isLocked = false
+        updateIsLockedTo(value: false)
         self.adaptInterfaceTo(deviceOrientation: deviceOrientation)
     }
 
+    @objc public func resetSupportedInterfaceOrientations() {
+        self.supportedInterfaceOrientations = self.initialSupportedInterfaceOrientations
+        self.requestInterfaceUpdateTo(mask: self.supportedInterfaceOrientations)
+        self.updateIsLockedTo(value: self.initIsLocked())
+
+        let lastMask = OrientationDirectorUtils.getMaskFrom(orientation: lastInterfaceOrientation)
+        let isLastInterfaceOrientationAlreadySupported = self.supportedInterfaceOrientations.contains(lastMask)
+        if (isLastInterfaceOrientationAlreadySupported) {
+            return
+        }
+
+        let supportedInterfaceOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        if (supportedInterfaceOrientations.contains(UIInterfaceOrientationMask.portrait)) {
+            self.updateLastInterfaceOrientation(value: Orientation.PORTRAIT)
+            return
+        }
+        if (supportedInterfaceOrientations.contains(UIInterfaceOrientationMask.landscapeRight)) {
+            self.updateLastInterfaceOrientation(value: Orientation.LANDSCAPE_LEFT)
+            return
+        }
+        if (supportedInterfaceOrientations.contains(UIInterfaceOrientationMask.landscapeLeft)) {
+            self.updateLastInterfaceOrientation(value: Orientation.LANDSCAPE_RIGHT)
+            return
+        }
+
+        self.updateLastInterfaceOrientation(value: Orientation.PORTRAIT_UPSIDE_DOWN)
+    }
+
+    private func initInitialSupportedInterfaceOrientations() -> UIInterfaceOrientationMask {
+        let supportedInterfaceOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        return supportedInterfaceOrientations.reduce(UIInterfaceOrientationMask()) { $0.union($1) }
+    }
+
     private func initInterfaceOrientation() -> Orientation {
         let interfaceOrientation = OrientationDirectorUtils.getInterfaceOrientation()
         return OrientationDirectorUtils.getOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
@@ -71,32 +109,37 @@ import UIKit
         return OrientationDirectorUtils.getOrientationFrom(deviceOrientation: UIDevice.current.orientation)
     }
 
+    private func initIsLocked() -> Bool {
+        let supportedOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        if (supportedOrientations.count > 1) {
+            return false
+        }
+
+        return supportedOrientations.first != UIInterfaceOrientationMask.all
+    }
+
     private func requestInterfaceUpdateTo(mask: UIInterfaceOrientationMask) {
-        self.supportedInterfaceOrientation = mask
-
-        DispatchQueue.main.async {
-            if #available(iOS 16.0, *) {
-                guard let window = OrientationDirectorUtils.getCurrentWindow() else {
-                    return
-                }
-
-                guard let rootViewController = window.rootViewController else {
-                    return
-                }
-
-                guard let windowScene = window.windowScene else {
-                    return
-                }
-
-                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()
+        self.supportedInterfaceOrientations = mask
+
+        if #available(iOS 16.0, *) {
+            let window = OrientationDirectorUtils.getCurrentWindow()
+
+            guard let rootViewController = window?.rootViewController else {
+                return
+            }
+
+            guard let windowScene = window?.windowScene else {
+                return
             }
+
+            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()
         }
     }
 
@@ -109,18 +152,33 @@ import UIKit
 
     private func adaptInterfaceTo(deviceOrientation: Orientation) {
         if (isLocked) {
-          return
+            return
         }
 
         if (lastInterfaceOrientation == deviceOrientation) {
-          return
+            return
         }
-
+        
         if (deviceOrientation == Orientation.FACE_UP || deviceOrientation == Orientation.FACE_DOWN) {
-          return
+            return
         }
 
-        self.eventManager.sendInterfaceOrientationDidChange(orientationValue: deviceOrientation.rawValue)
-        lastInterfaceOrientation = deviceOrientation
-      }
+        let deviceOrientationMask = OrientationDirectorUtils.getMaskFrom(orientation: deviceOrientation)
+        let isDeviceOrientationMaskSupported = self.supportedInterfaceOrientations.contains(deviceOrientationMask)
+        if (!isDeviceOrientationMaskSupported) {
+            return
+        }
+
+        updateLastInterfaceOrientation(value: deviceOrientation)
+    }
+
+    private func updateIsLockedTo(value: Bool) {
+        eventManager.sendLockDidChange(value: value)
+        isLocked = value
+    }
+
+    private func updateLastInterfaceOrientation(value: Orientation) {
+        self.eventManager.sendInterfaceOrientationDidChange(orientationValue: value.rawValue)
+        lastInterfaceOrientation = value
+    }
 }