expo-screen-orientation 5.2.0 → 6.0.0

package/CHANGELOG.md

@@ -10,6 +10,27 @@
 
 ### 💡 Others
 
+## 6.0.0 — 2023-06-21
+
+_This version does not introduce any user-facing changes._
+
+## 6.0.0-beta.1 — 2023-06-13
+
+### 🎉 New features
+
+- Added support for React Native 0.72. ([#22588](https://github.com/expo/expo/pull/22588) by [@kudo](https://github.com/kudo))
+
+### 🐛 Bug fixes
+
+- Fixed Android build warnings for Gradle version 8. ([#22537](https://github.com/expo/expo/pull/22537), [#22609](https://github.com/expo/expo/pull/22609) by [@kudo](https://github.com/kudo))
+- [iOS] Fixed screen orientation on iOS 16. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+- [iOS] Fixed status bar and navigation bar following the device's orientation regardless of applied orientation lock. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+- [iOS] Fixed SafeAreaViews failing after pulling down quick settings when the device is in a different orientation than the current orientation lock allows. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+
+### 💡 Others
+
+- [iOS] Migrated to new modules API. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+
 ## 5.2.0 — 2023-05-08
 
 ### 🎉 New features

package/README.md

@@ -1,4 +1,11 @@
-# expo-screen-orientation
+<p>
+  <a href="https://docs.expo.dev/versions/latest/sdk/screen-orientation/">
+    <img
+      src="../../.github/resources/expo-screen-orientation.svg"
+      alt="expo-screen-orientation"
+      height="64" />
+  </a>
+</p>
 
 Allows you to manage the orientation of your app's interface.
 

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '5.2.0'
+version = '6.0.0'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -35,19 +35,11 @@ buildscript {
   }
 }
 
-// Creating sources with comments
-task androidSourcesJar(type: Jar) {
-  classifier = 'sources'
-  from android.sourceSets.main.java.srcDirs
-}
-
 afterEvaluate {
   publishing {
     publications {
       release(MavenPublication) {
         from components.release
-        // Add additional sourcesJar to artifacts
-        artifact(androidSourcesJar)
       }
     }
     repositories {
@@ -70,15 +62,21 @@ android {
     jvmTarget = JavaVersion.VERSION_11.majorVersion
   }
 
+  namespace "expo.modules.screenorientation"
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 7
-    versionName '5.2.0'
+    versionName '6.0.0'
   }
   lintOptions {
     abortOnError false
   }
+  publishing {
+    singleVariant("release") {
+      withSourcesJar()
+    }
+  }
 }
 
 dependencies {

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,2 @@
-<manifest package="expo.modules.screenorientation">
+<manifest>
 </manifest>

package/android/src/main/java/expo/modules/screenorientation/ScreenOrientationModule.kt

@@ -17,8 +17,12 @@ import expo.modules.screenorientation.enums.OrientationAttr
 import expo.modules.screenorientation.enums.OrientationLock
 
 class ScreenOrientationModule : Module(), LifecycleEventListener {
+  private val weakCurrentActivity
+    get() = appContext.activityProvider?.currentActivity
+
   private val currentActivity
-    get() = appContext.activityProvider?.currentActivity ?: throw Exceptions.MissingActivity()
+    get() = weakCurrentActivity ?: throw Exceptions.MissingActivity()
+
   private val uiManager
     get() = appContext.legacyModuleRegistry.getModule(UIManager::class.java)
       ?: throw IllegalStateException("Could not find implementation for UIManager.")
@@ -71,13 +75,13 @@ class ScreenOrientationModule : Module(), LifecycleEventListener {
     OnDestroy {
       uiManager.unregisterLifecycleEventListener(this@ScreenOrientationModule)
       initialOrientation?.let {
-        currentActivity.requestedOrientation = it
+        weakCurrentActivity?.requestedOrientation = it
       }
     }
   }
 
   override fun onHostResume() {
-    initialOrientation = initialOrientation ?: currentActivity.requestedOrientation
+    initialOrientation = initialOrientation ?: weakCurrentActivity?.requestedOrientation
   }
 
   override fun onHostPause() = Unit

package/build/ExpoScreenOrientation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoScreenOrientation.d.ts","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":";AAGA,wBAEmD"}
+{"version":3,"file":"ExpoScreenOrientation.d.ts","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":";AAEA,wBAA4D"}

package/build/ExpoScreenOrientation.js

@@ -1,6 +1,3 @@
-import { NativeModulesProxy, requireNativeModule } from 'expo-modules-core';
-import { Platform } from 'react-native';
-export default Platform.OS === 'android'
-    ? requireNativeModule('ExpoScreenOrientation')
-    : NativeModulesProxy.ExpoScreenOrientation || {};
+import { requireNativeModule } from 'expo-modules-core';
+export default requireNativeModule('ExpoScreenOrientation');
 //# sourceMappingURL=ExpoScreenOrientation.js.map

package/build/ExpoScreenOrientation.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoScreenOrientation.js","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,eAAe,QAAQ,CAAC,EAAE,KAAK,SAAS;IACtC,CAAC,CAAC,mBAAmB,CAAC,uBAAuB,CAAC;IAC9C,CAAC,CAAC,kBAAkB,CAAC,qBAAqB,IAAI,EAAE,CAAC","sourcesContent":["import { NativeModulesProxy, requireNativeModule } from 'expo-modules-core';\nimport { Platform } from 'react-native';\n\nexport default Platform.OS === 'android'\n  ? requireNativeModule('ExpoScreenOrientation')\n  : NativeModulesProxy.ExpoScreenOrientation || {};\n"]}
+{"version":3,"file":"ExpoScreenOrientation.js","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,eAAe,mBAAmB,CAAC,uBAAuB,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\n\nexport default requireNativeModule('ExpoScreenOrientation');\n"]}

package/expo-module.config.json

@@ -6,6 +6,7 @@
   },
   "ios": {
     "appDelegateSubscribers": ["ScreenOrientationAppDelegate"],
-    "reactDelegateHandlers": ["ScreenOrientationReactDelegateHandler"]
+    "reactDelegateHandlers": ["ScreenOrientationReactDelegateHandler"],
+    "modules": ["ScreenOrientationModule"]
   }
 }

package/ios/{EXScreenOrientation.podspec → ExpoScreenOrientation.podspec}

@@ -3,7 +3,7 @@ require 'json'
 package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
 
 Pod::Spec.new do |s|
-  s.name           = 'EXScreenOrientation'
+  s.name           = 'ExpoScreenOrientation'
   s.version        = package['version']
   s.summary        = package['description']
   s.description    = package['description']
@@ -18,6 +18,13 @@ Pod::Spec.new do |s|
   s.dependency 'ExpoModulesCore'
   s.dependency 'React-Core'
 
+  unless defined?(install_modules_dependencies)
+    # `install_modules_dependencies` is defined from react_native_pods.rb.
+    # when running with `pod ipc spec`, this method is not defined and we have to require manually.
+    require File.join(File.dirname(`node --print "require.resolve('react-native/package.json')"`), "scripts/react_native_pods")
+  end
+  install_modules_dependencies(s)
+
   # Swift/Objective-C compatibility
   s.pod_target_xcconfig = {
     'DEFINES_MODULE' => 'YES'
@@ -27,6 +34,6 @@ Pod::Spec.new do |s|
     s.source_files = "#{s.name}/**/*.h"
     s.vendored_frameworks = "#{s.name}.xcframework"
   else
-    s.source_files = "#{s.name}/**/*.{h,m,swift}"
+    s.source_files = "**/*.{h,m,swift}"
   end
 end

package/ios/{EXScreenOrientation/ScreenOrientationAppDelegate.swift → ScreenOrientationAppDelegate.swift}

@@ -4,9 +4,11 @@ import ExpoModulesCore
 
 public class ScreenOrientationAppDelegate: ExpoAppDelegateSubscriber {
   public func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
-    if let screenOrientationRegistry = ModuleRegistryProvider.getSingletonModule(for: EXScreenOrientationRegistry.self) as? EXScreenOrientationRegistry {
-      screenOrientationRegistry.updateCurrentScreenOrientation()
-    }
+    ScreenOrientationRegistry.shared.updateCurrentScreenOrientation()
     return true
   }
+
+  public func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
+    return ScreenOrientationRegistry.shared.currentOrientationMask
+  }
 }

package/ios/ScreenOrientationExceptions.swift

@@ -0,0 +1,16 @@
+import ExpoModulesCore
+
+internal class InvalidOrientationLockException: Exception {
+  override var reason: String {
+    "Invalid screen orientation lock"
+  }
+}
+
+internal class UnsupportedOrientationLockException: GenericException<ModuleOrientationLock?> {
+  override var reason: String {
+    guard let param = param else {
+      return "This device does not support the requested orientation"
+    }
+    return "This device does not support the requested orientation: \(param)"
+  }
+}

package/ios/ScreenOrientationModule.swift

@@ -0,0 +1,118 @@
+import ExpoModulesCore
+
+public class ScreenOrientationModule: Module, OrientationListener, Hashable {
+  static let didUpdateDimensionsEvent = "expoDidUpdateDimensions"
+
+  let screenOrientationRegistry = ScreenOrientationRegistry.shared
+  var eventEmitter: EXEventEmitterService?
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoScreenOrientation")
+
+    Events("expoDidUpdateDimensions")
+
+    AsyncFunction("lockAsync") { (orientationLock: ModuleOrientationLock) in
+      let orientationMask = orientationLock.toInterfaceOrientationMask()
+
+      guard !orientationMask.isEmpty else {
+        throw InvalidOrientationLockException()
+      }
+
+      guard orientationMask.isSupportedByDevice() else {
+        throw UnsupportedOrientationLockException(orientationLock)
+      }
+
+      screenOrientationRegistry.setMask(orientationMask, forModule: self)
+    }
+
+    AsyncFunction("lockPlatformAsync") { (allowedOrientations: [ModuleOrientation]) in
+      var allowedOrientationsMask: UIInterfaceOrientationMask = []
+
+      for allowedOrientation in allowedOrientations {
+        let orientation = allowedOrientation.toInterfaceOrientation()
+        let orientationMask = orientation.toInterfaceOrientationMask()
+
+        guard !orientationMask.isEmpty else {
+          throw InvalidOrientationLockException()
+        }
+
+        allowedOrientationsMask.insert(orientationMask)
+      }
+
+      guard allowedOrientationsMask.isSupportedByDevice() else {
+        throw UnsupportedOrientationLockException(nil)
+      }
+
+      screenOrientationRegistry.setMask(allowedOrientationsMask, forModule: self)
+    }
+
+    AsyncFunction("getOrientationLockAsync") {
+      return ModuleOrientationLock.from(mask: screenOrientationRegistry.currentOrientationMask).rawValue
+    }
+
+    AsyncFunction("getPlatformOrientationLockAsync") { () -> [Int] in
+      let orientationMask = screenOrientationRegistry.currentOrientationMask
+      var allowedOrientations: [Int] = []
+      let orientationMasks: [UIInterfaceOrientationMask] = [.portrait, .portraitUpsideDown, .landscapeLeft, .landscapeRight]
+
+      // If the particular orientation is supported, we add it to the array of allowedOrientations
+      for wrappedSingleOrientation in orientationMasks {
+        let supportedOrientationMask = orientationMask.intersection(wrappedSingleOrientation)
+        if !supportedOrientationMask.isEmpty {
+          let supportedOrientation = supportedOrientationMask.toUIInterfaceOrientation()
+          allowedOrientations.append(ModuleOrientation.from(orientation: supportedOrientation).rawValue)
+        }
+      }
+      return allowedOrientations
+    }
+
+    AsyncFunction("supportsOrientationLockAsync") { (orientationLock: ModuleOrientationLock) -> Bool in
+      let orientationMask = orientationLock.toInterfaceOrientationMask()
+      return !orientationMask.isEmpty && orientationMask.isSupportedByDevice()
+    }
+
+    AsyncFunction("getOrientationAsync") {
+      return ModuleOrientation.from(orientation: screenOrientationRegistry.currentScreenOrientation).rawValue
+    }
+
+    OnStartObserving {
+      screenOrientationRegistry.registerModuleToReceiveNotification(self)
+    }
+
+    OnStopObserving {
+      screenOrientationRegistry.unregisterModuleFromReceivingNotification(self)
+    }
+
+    OnDestroy {
+      screenOrientationRegistry.unregisterModuleFromReceivingNotification(self)
+      screenOrientationRegistry.moduleWillDeallocate(self)
+    }
+  }
+
+  // MARK: - ScreenOrientationListener
+
+  func screenOrientationDidChange(_ orientation: UIInterfaceOrientation) {
+    guard let currentTraitCollection = screenOrientationRegistry.currentTraitCollection else {
+      return
+    }
+
+    sendEvent(ScreenOrientationModule.didUpdateDimensionsEvent, [
+      "orientationLock": ModuleOrientationLock.from(mask: screenOrientationRegistry.currentOrientationMask).rawValue,
+      "orientationInfo": [
+        "orientation": ModuleOrientation.from(orientation: orientation).rawValue,
+        "verticalSizeClass": currentTraitCollection.verticalSizeClass,
+        "horizontalSizeClass": currentTraitCollection.horizontalSizeClass
+      ] as [String: Any]
+    ])
+  }
+
+  // MARK: - Hashable
+
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(ObjectIdentifier(self))
+  }
+
+  public static func == (lhs: ScreenOrientationModule, rhs: ScreenOrientationModule) -> Bool {
+    return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
+  }
+}

package/ios/ScreenOrientationRNSScreenWindowTraits.h

@@ -0,0 +1,11 @@
+#import <UIKit/UIKit.h>
+
+/**
+ This is necessary for the shouldUseRNSScreensOrientation function in ScreenOrientationViewController
+ This is a copy of the RNSScreens Protocol
+ */
+@protocol ScreenOrientationRNSScreenWindowTraits
+
++ (BOOL)shouldAskScreensForScreenOrientationInViewController:(UIViewController *)vc;
+
+@end

package/ios/{EXScreenOrientation/ScreenOrientationReactDelegateHandler.swift → ScreenOrientationReactDelegateHandler.swift}

@@ -4,6 +4,6 @@ import ExpoModulesCore
 
 public class ScreenOrientationReactDelegateHandler: ExpoReactDelegateHandler {
   public override func createRootViewController(reactDelegate: ExpoReactDelegate) -> UIViewController? {
-    return EXScreenOrientationViewController(defaultScreenOrientationFromPlist: ())
+    return ScreenOrientationViewController(defaultScreenOrientationFromPlist: ())
   }
 }

package/ios/ScreenOrientationRegistry.swift

@@ -0,0 +1,252 @@
+import Foundation
+import ExpoModulesCore
+
+protocol OrientationListener {
+  func screenOrientationDidChange(_ orientation: UIInterfaceOrientation)
+}
+
+/**
+ This singleton that holds information about desired orientation for every app which uses expo-screen-orientation.
+ Marked @objc and public, because this it is also used in EXAppViewController.
+ */
+@objc
+public class ScreenOrientationRegistry: NSObject, UIApplicationDelegate {
+  @objc
+  public static let shared = ScreenOrientationRegistry()
+
+  var currentScreenOrientation: UIInterfaceOrientation
+  var orientationListeners: [ScreenOrientationModule?] = []
+  var moduleInterfaceMasks: [ScreenOrientationModule: UIInterfaceOrientationMask] = [:]
+  weak var currentTraitCollection: UITraitCollection?
+  var lastOrientationMask: UIInterfaceOrientationMask
+  var rootViewController: UIViewController? {
+    return UIApplication.shared.keyWindow?.rootViewController
+  }
+
+  var currentOrientationMask: UIInterfaceOrientationMask {
+    var currentOrientationMask: UIInterfaceOrientationMask = []
+
+    EXUtilities.performSynchronously {
+      currentOrientationMask = self.rootViewController?.supportedInterfaceOrientations ?? []
+    }
+    return currentOrientationMask
+  }
+
+  private override init() {
+    self.currentScreenOrientation = .unknown
+    self.currentTraitCollection = nil
+    self.lastOrientationMask = []
+
+    super.init()
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(self.handleDeviceOrientationChange(notification:)),
+      name: UIDevice.orientationDidChangeNotification,
+      object: UIDevice.current
+    )
+
+    // This is most likely already executed on the main thread, but we need to be sure
+    RCTExecuteOnMainQueue {
+      UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+    }
+  }
+
+  /**
+   Called by ScreenOrientationAppDelegate in order to set initial interface orientation.
+   */
+  func updateCurrentScreenOrientation() {
+    let windows = UIApplication.shared.windows
+    if !windows.isEmpty {
+      self.currentScreenOrientation = windows[0].windowScene?.interfaceOrientation ?? .unknown
+    }
+  }
+
+  deinit {
+    EXUtilities.performSynchronously {
+      UIDevice.current.endGeneratingDeviceOrientationNotifications()
+    }
+  }
+
+  // MARK: - Affecting screen orientation
+
+  /**
+   Rotates the view to currentScreenOrientation or default orientation from the orientationMask.
+   */
+  func enforceDesiredDeviceOrientation(withOrientationMask orientationMask: UIInterfaceOrientationMask) {
+    var newOrientation = orientationMask.defaultOrientation()
+
+    if orientationMask.contains(currentScreenOrientation) {
+      newOrientation = currentScreenOrientation
+    }
+
+    guard newOrientation != .unknown else {
+      return
+    }
+
+    RCTExecuteOnMainQueue { [weak self] in
+      guard let self = self else {
+        return
+      }
+
+      if #available(iOS 16.0, *) {
+        let windowScene = self.rootViewController?.view.window?.windowScene
+        windowScene?.requestGeometryUpdate(.iOS(interfaceOrientations: orientationMask))
+        self.rootViewController?.setNeedsUpdateOfSupportedInterfaceOrientations()
+      } else {
+        UIDevice.current.setValue(newOrientation.rawValue, forKey: "orientation")
+        UIViewController.attemptRotationToDeviceOrientation()
+      }
+
+      if self.currentScreenOrientation == .unknown {
+        // CurrentScreenOrientation might be unknown (especially just after launch), but at this point we already know it.
+        // Later the currentScreenOrientation will be updated by the iOS orientation change notifications.
+        self.screenOrientationDidChange(newOrientation)
+      }
+    }
+  }
+
+  func setMask(_ mask: UIInterfaceOrientationMask, forModule module: ScreenOrientationModule) {
+    moduleInterfaceMasks[module] = mask
+    enforceDesiredDeviceOrientation(withOrientationMask: mask)
+  }
+
+  // MARK: - Getters
+
+  /**
+   Gets the orientationMask for the app. Uses an intersection of all applied orientation masks. Also used for Expo Go in EXAppViewController.
+   */
+  @objc
+  public func requiredOrientationMask() -> UIInterfaceOrientationMask {
+    if moduleInterfaceMasks.isEmpty {
+      return []
+    }
+
+    // We want to apply an orientation mask which is an intersection of locks applied by the modules.
+    var mask = doesDeviceHaveNotch ? UIInterfaceOrientationMask.allButUpsideDown : UIInterfaceOrientationMask.all
+
+    for moduleMask in moduleInterfaceMasks {
+      mask = mask.intersection(moduleMask.value)
+    }
+
+    return mask
+  }
+
+  // MARK: - Events
+
+  /**
+   Called when the OS sends an OrientationDidChange notification.
+   */
+  @objc
+  func handleDeviceOrientationChange(notification: Notification) {
+    let newScreenOrientation = UIDevice.current.orientation.toInterfaceOrientation()
+
+    interfaceOrientationDidChange(newScreenOrientation)
+  }
+
+  /**
+   Called when the device is physically rotated. Checks if screen orientation should be changed after user rotated the device.
+   */
+  func interfaceOrientationDidChange(_ newScreenOrientation: UIInterfaceOrientation) {
+    if currentScreenOrientation == newScreenOrientation || newScreenOrientation == .unknown {
+      return
+    }
+
+    if currentOrientationMask.contains(newScreenOrientation) {
+      // when changing orientation without changing dimensions traitCollectionDidChange isn't triggered so the event has to be called manually
+      if (newScreenOrientation.isPortrait && currentScreenOrientation.isPortrait)
+        || (newScreenOrientation.isLandscape && currentScreenOrientation.isLandscape) {
+        screenOrientationDidChange(newScreenOrientation)
+        return
+      }
+
+      // on iPads, traitCollectionDidChange isn't triggered at all, so we have to call screenOrientationDidChange manually
+      if isPad()
+        && (newScreenOrientation.isPortrait && currentScreenOrientation.isLandscape
+        || newScreenOrientation.isLandscape && currentScreenOrientation.isPortrait) {
+        screenOrientationDidChange(newScreenOrientation)
+      }
+    }
+  }
+
+  /**
+   Called by ScreenOrientationViewController when the dimensions of the view change.
+   Also used for Expo Go in EXAppViewController.
+   */
+  @objc
+  public func traitCollectionDidChange(to traitCollection: UITraitCollection) {
+    currentTraitCollection = traitCollection
+
+    let currentDeviceOrientation = UIDevice.current.orientation.toInterfaceOrientation()
+    let currentOrientationMask = self.rootViewController?.supportedInterfaceOrientations ?? []
+
+    var newScreenOrientation = UIInterfaceOrientation.unknown
+
+    // We need to deduce what is the new screen orientaiton based on currentOrientationMask and new dimensions of the view
+    if traitCollection.isPortrait() {
+      // From trait collection, we know that screen is in portrait or upside down orientation.
+      let portraitMask = currentOrientationMask.intersection([.portrait, .portraitUpsideDown])
+
+      if portraitMask == .portrait {
+        // Mask allows only proper portrait - we know that the device is in either proper portrait or upside down
+        // we deduce it is proper portrait.
+        newScreenOrientation = .portrait
+      } else if portraitMask == .portraitUpsideDown {
+        // Mask allows only upside down portrait - we know that the device is in either proper portrait or upside down
+        // we deduce it is upside down portrait.
+        newScreenOrientation = .portraitUpsideDown
+      } else if currentDeviceOrientation == .portrait || currentDeviceOrientation == .portraitUpsideDown {
+        // Mask allows portrait or upside down portrait - we can try to deduce orientation
+        // from device orientation.
+        newScreenOrientation = currentDeviceOrientation
+      }
+    } else if traitCollection.isLandscape() {
+      // From trait collection, we know that screen is in landscape left or right orientation.
+      let landscapeMask = currentOrientationMask.intersection(.landscape)
+
+      if landscapeMask == .landscapeLeft {
+        // Mask allows only proper landscape - we know that the device is in either proper landscape left or right
+        // we deduce it is proper left.
+        newScreenOrientation = .landscapeLeft
+      } else if landscapeMask == .landscapeRight {
+        // Mask allows only landscape right - we know that the device is in either proper landscape left or right
+        // we deduce it is landscape right.
+        newScreenOrientation = .landscapeRight
+      } else if currentDeviceOrientation == .landscapeLeft || currentDeviceOrientation == .landscapeRight {
+        // Mask allows landscape left or right - we can try to deduce orientation
+        // from device orientation.
+        newScreenOrientation = currentDeviceOrientation
+      } else if currentDeviceOrientation == .portrait || currentDeviceOrientation == .portraitUpsideDown {
+        // If the desired orientation is .landscape but the device is in .portrait orientation it will rotate to .landscapeRight
+        newScreenOrientation = .landscapeRight
+      }
+    }
+    screenOrientationDidChange(newScreenOrientation)
+  }
+
+  /**
+   Called at the end of the screen orientation change. Notifies modules about the orientation change.
+   */
+  func screenOrientationDidChange(_ newScreenOrientation: UIInterfaceOrientation) {
+    currentScreenOrientation = newScreenOrientation
+    for module in orientationListeners {
+      module?.screenOrientationDidChange(newScreenOrientation)
+    }
+  }
+
+  func moduleWillDeallocate(_ module: ScreenOrientationModule) {
+    moduleInterfaceMasks.removeValue(forKey: module)
+  }
+
+  func registerModuleToReceiveNotification(_ module: ScreenOrientationModule) {
+    orientationListeners.append(module)
+  }
+
+  func unregisterModuleFromReceivingNotification(_ module: ScreenOrientationModule) {
+    for i in (0..<orientationListeners.count).reversed() {
+      if orientationListeners[i] === module || orientationListeners[i] == nil {
+        orientationListeners.remove(at: i)
+      }
+    }
+  }
+}