expo-screen-orientation 5.2.0 → 6.0.0

package/ios/ScreenOrientationUtilities.swift

@@ -0,0 +1,110 @@
+import ExpoModulesCore
+
+internal func isPad() -> Bool {
+  return UIDevice.current.userInterfaceIdiom == .pad
+}
+
+// https://medium.com/@cafielo/how-to-detect-notch-screen-in-swift-56271827625d
+internal var doesDeviceHaveNotch = {
+  var bottomSafeAreaInsetIsPositive = false
+  EXUtilities.performSynchronously {
+    bottomSafeAreaInsetIsPositive = (UIApplication.shared.delegate?.window??.safeAreaInsets.bottom ?? 0.0) > 0.0
+  }
+  return bottomSafeAreaInsetIsPositive
+}()
+
+extension UIInterfaceOrientationMask {
+  internal func toUIInterfaceOrientation() -> UIInterfaceOrientation {
+    switch self {
+    case .portrait: return .portrait
+    case .portraitUpsideDown: return.portraitUpsideDown
+    case .landscapeLeft: return .landscapeLeft
+    case .landscapeRight: return .landscapeRight
+    default: return .unknown
+    }
+  }
+
+  internal func contains(_ orientation: UIInterfaceOrientation) -> Bool {
+    // This is how the mask is created from the orientation
+    let maskFromOrientation = orientation.toInterfaceOrientationMask()
+    return self.contains(maskFromOrientation)
+  }
+
+  internal func isSupportedByDevice() -> Bool {
+    // Devices with a notch don't support upside down orientation mask.
+    return !self.contains(.portraitUpsideDown) || !doesDeviceHaveNotch
+  }
+
+  internal func defaultOrientation() -> UIInterfaceOrientation {
+    if self.contains(.portrait) {
+      return .portrait
+    }
+    if self.contains(.landscapeLeft) {
+      return .landscapeLeft
+    }
+    if self.contains(.landscapeRight) {
+      return .landscapeRight
+    }
+    if self.contains(.portraitUpsideDown) {
+      return .portraitUpsideDown
+    }
+    return .unknown
+  }
+}
+
+internal func plistStringToInterfaceOrientationMask(_ maskName: String) -> UIInterfaceOrientationMask? {
+  switch maskName {
+  case "UIInterfaceOrientationMaskPortrait":
+    return .portrait
+  case "UIInterfaceOrientationMaskLandscapeLeft":
+    return .landscapeLeft
+  case "UIInterfaceOrientationMaskLandscapeRight":
+    return .landscapeRight
+  case "UIInterfaceOrientationMaskPortraitUpsideDown":
+    return .portraitUpsideDown
+  case "UIInterfaceOrientationMaskLandscape":
+    return .landscape
+  case "UIInterfaceOrientationMaskAll":
+    return .all
+  case "UIInterfaceOrientationMaskAllButUpsideDown":
+    return .allButUpsideDown
+  default:
+    return nil
+  }
+}
+
+extension UIInterfaceOrientation {
+  internal func toInterfaceOrientationMask() -> UIInterfaceOrientationMask {
+    return UIInterfaceOrientationMask(rawValue: 1 << self.rawValue)
+  }
+}
+
+extension UIDeviceOrientation {
+  internal func toInterfaceOrientation() -> UIInterfaceOrientation {
+    switch self {
+    case .portrait:
+      return .portrait
+    case .portraitUpsideDown:
+      return .portraitUpsideDown
+      // UIDevice and UIInterface landscape orientations are switched
+    case .landscapeLeft:
+      return .landscapeRight
+    case .landscapeRight:
+      return .landscapeLeft
+    default:
+      return .unknown
+    }
+  }
+}
+
+extension UITraitCollection {
+  internal func isPortrait() -> Bool {
+    return verticalSizeClass == .regular && horizontalSizeClass == .compact
+  }
+
+  internal func isLandscape() -> Bool {
+    return (verticalSizeClass == .compact && horizontalSizeClass == .compact)
+    || (verticalSizeClass == .regular && horizontalSizeClass == .regular)
+    || (verticalSizeClass == .compact && horizontalSizeClass == .regular)
+  }
+}

package/ios/ScreenOrientationViewController.swift

@@ -0,0 +1,64 @@
+import ExpoModulesCore
+
+let defaultScreenOrientationMask = "EXDefaultScreenOrientationMask"
+
+class ScreenOrientationViewController: UIViewController {
+  let screenOrientationRegistry = ScreenOrientationRegistry.shared
+  private var defaultOrientationMask: UIInterfaceOrientationMask
+
+  init(defaultOrientationMask: UIInterfaceOrientationMask = .portrait) {
+    self.defaultOrientationMask = defaultOrientationMask
+    super.init(nibName: nil, bundle: nil)
+  }
+
+  convenience init(defaultScreenOrientationFromPlist: Void) {
+    guard let orientationString = Bundle.main.object(forInfoDictionaryKey: defaultScreenOrientationMask) as? String else {
+      self.init(defaultOrientationMask: .portrait)
+      return
+    }
+
+    guard let mask = plistStringToInterfaceOrientationMask(orientationString) else {
+      log.warn("Orientation lock string '\(orientationString)' provided in Info.plist does not correspond to a valid orientation mask. Application will default to portrait orientation lock.")
+      self.init(defaultOrientationMask: .portrait)
+      return
+    }
+
+    guard mask.isSupportedByDevice() else {
+      log.warn("Orientation lock string '\(orientationString)' provided in Info.plist is not supported by the device. Application will default to portrait orientation lock.")
+      self.init(defaultOrientationMask: .portrait)
+      return
+    }
+
+    self.init(defaultOrientationMask: mask)
+  }
+
+  @available(*, unavailable)
+  required init?(coder aDecoder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+    guard !shouldUseRNScreenOrientation() else {
+      return super.supportedInterfaceOrientations
+    }
+    let mask = screenOrientationRegistry.requiredOrientationMask()
+    return !mask.isEmpty ? mask : defaultOrientationMask
+  }
+
+  override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
+    super.traitCollectionDidChange(previousTraitCollection)
+
+    if traitCollection.verticalSizeClass != previousTraitCollection?.verticalSizeClass ||
+      traitCollection.horizontalSizeClass != previousTraitCollection?.horizontalSizeClass {
+      screenOrientationRegistry.traitCollectionDidChange(to: traitCollection)
+    }
+  }
+
+  private func shouldUseRNScreenOrientation() -> Bool {
+    // If RNScreens has set the orientation we want to use it instead of our orientation
+    guard let screenWindowTraitsClass = NSClassFromString("RNSScreenWindowTraits") else {
+      return false
+    }
+    return screenWindowTraitsClass.shouldAskScreensForScreenOrientation?(in: self) ?? false
+  }
+}

package/ios/enums/ModuleOrientation.swift

@@ -0,0 +1,39 @@
+import ExpoModulesCore
+
+enum ModuleOrientation: Int, Enumerable {
+  case unknown = 0
+  case portraitUp = 1
+  case portraitDown = 2
+  case landscapeLeft = 3
+  case landscapeRight = 4
+
+  static func from (orientation interfaceOrientation: UIInterfaceOrientation) -> ModuleOrientation {
+    switch interfaceOrientation {
+    case .portrait:
+      return .portraitUp
+    case .portraitUpsideDown:
+      return .portraitDown
+    case .landscapeLeft:
+      return .landscapeLeft
+    case .landscapeRight:
+      return .landscapeRight
+    case .unknown:
+      return .unknown
+    }
+  }
+
+  func toInterfaceOrientation() -> UIInterfaceOrientation {
+    switch self {
+    case .portraitUp:
+      return .portrait
+    case .portraitDown:
+      return .portraitUpsideDown
+    case .landscapeLeft:
+      return .landscapeLeft
+    case .landscapeRight:
+      return .landscapeRight
+    case .unknown:
+      return .unknown
+    }
+  }
+}

package/ios/enums/ModuleOrientationLock.swift

@@ -0,0 +1,60 @@
+import ExpoModulesCore
+
+internal enum ModuleOrientationLock: Int, Enumerable {
+  case allButUpsideDown = 0
+  case all = 1
+  case portrait = 2
+  case portraitUp = 3
+  case portraitDown = 4
+  case landscape = 5
+  case landscapeLeft = 6
+  case landscapeRight = 7
+  case other = 8
+  case unknown = 9
+
+  static func from(mask: UIInterfaceOrientationMask) -> ModuleOrientationLock {
+    switch mask {
+    case .allButUpsideDown:
+      return .allButUpsideDown
+    case .all:
+      return .all
+    case [.portrait, .portraitUpsideDown]:
+      return .portrait
+    case .portrait:
+      return .portraitUp
+    case .portraitUpsideDown:
+      return .portraitDown
+    case .landscape:
+      return .landscape
+    case .landscapeLeft:
+      return .landscapeLeft
+    case .landscapeRight:
+      return .landscapeRight
+    default:
+      return UIInterfaceOrientationMask.all.contains(mask) ? .other : .unknown
+    }
+  }
+
+  func toInterfaceOrientationMask() -> UIInterfaceOrientationMask {
+    switch self {
+    case .allButUpsideDown:
+      return .allButUpsideDown
+    case .all:
+      return .all
+    case .portrait:
+      return [.portrait, .portraitUpsideDown]
+    case .portraitUp:
+      return .portrait
+    case .portraitDown:
+      return .portraitUpsideDown
+    case .landscape:
+      return .landscape
+    case .landscapeLeft:
+      return .landscapeLeft
+    case .landscapeRight:
+      return .landscapeRight
+    default:
+      return []
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-screen-orientation",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "description": "Expo universal module for managing device's screen orientation",
   "main": "build/ScreenOrientation.js",
   "types": "build/ScreenOrientation.d.ts",
@@ -41,5 +41,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "4ba50c428c8369bb6b3a51a860d4898ad4ccbe78"
+  "gitHead": "fa5ecca8251986b9f197cc14074eec0ab6dfb6db"
 }

package/src/ExpoScreenOrientation.ts

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

package/ios/EXScreenOrientation/EXScreenOrientationModule.h

@@ -1,11 +0,0 @@
-//  Copyright © 2019-present 650 Industries. All rights reserved.
-
-#import <ExpoModulesCore/EXEventEmitter.h>
-#import <ExpoModulesCore/EXExportedModule.h>
-#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
-#import <ExpoModulesCore/EXAppLifecycleListener.h>
-#import <EXScreenOrientation/EXScreenOrientationRegistry.h>
-
-@interface EXScreenOrientationModule : EXExportedModule <EXModuleRegistryConsumer, EXEventEmitter, EXAppLifecycleListener, EXOrientationListener>
-
-@end

package/ios/EXScreenOrientation/EXScreenOrientationModule.m

@@ -1,177 +0,0 @@
-// Copyright 2019-present 650 Industries. All rights reserved.
-
-#import <ExpoModulesCore/EXAppLifecycleService.h>
-#import <ExpoModulesCore/EXDefines.h>
-#import <ExpoModulesCore/EXEventEmitterService.h>
-#import <ExpoModulesCore/EXModuleRegistryProvider.h>
-
-#import <EXScreenOrientation/EXScreenOrientationModule.h>
-#import <EXScreenOrientation/EXScreenOrientationUtilities.h>
-#import <EXScreenOrientation/EXScreenOrientationRegistry.h>
-
-#import <UIKit/UIKit.h>
-
-static NSString *const EXScreenOrientationDidUpdateDimensions = @"expoDidUpdateDimensions";
-
-@interface EXScreenOrientationModule ()
-
-@property (nonatomic, weak) EXScreenOrientationRegistry *screenOrientationRegistry;
-@property (nonatomic, weak) id<EXEventEmitterService> eventEmitter;
-
-@end
-
-@implementation EXScreenOrientationModule
-
-EX_EXPORT_MODULE(ExpoScreenOrientation);
-
--(void)dealloc
-{
-  [self stopObserving];
-  [_screenOrientationRegistry moduleWillDeallocate:self];
-}
-
-- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
-{
-  _screenOrientationRegistry = [moduleRegistry getSingletonModuleForName:@"ScreenOrientationRegistry"];
-  [[moduleRegistry getModuleImplementingProtocol:@protocol(EXAppLifecycleService)] registerAppLifecycleListener:self];
-  _eventEmitter = [moduleRegistry getModuleImplementingProtocol:@protocol(EXEventEmitterService)];
-
-  // TODO: This shouldn't be here, but it temporarily fixes
-  // https://github.com/expo/expo/issues/13641 and https://github.com/expo/expo/issues/11558
-  // We're going to redesign this once we drop support for multiple apps being open in Expo Go at the same time.
-  // Then we probably won't need the screen orientation registry at all. (@tsapeta)
-  [self onAppForegrounded];
-}
-
-EX_EXPORT_METHOD_AS(lockAsync,
-                    lockAsync:(NSNumber *)orientationLock
-                    resolver:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  UIInterfaceOrientationMask orientationMask = [EXScreenOrientationUtilities importOrientationLock:orientationLock];
-  
-  if (!orientationMask) {
-    return reject(@"ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK", [NSString stringWithFormat:@"Invalid screen orientation lock %@", orientationLock], nil);
-  }
-  if (![EXScreenOrientationUtilities doesDeviceSupportOrientationMask:orientationMask]) {
-    return reject(@"ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK", [NSString stringWithFormat:@"This device does not support the requested orientation %@", orientationLock], nil);
-  }
-  
-  [_screenOrientationRegistry setMask:orientationMask forModule:self];
-  resolve(nil);
-}
-
-EX_EXPORT_METHOD_AS(lockPlatformAsync,
-                    lockPlatformAsync:(NSArray <NSNumber *> *)allowedOrientations
-                    resolver:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  // combine all the allowedOrientations into one bitmask
-  UIInterfaceOrientationMask allowedOrientationsMask = 0;
-  for (NSNumber *allowedOrientation in allowedOrientations) {
-    UIInterfaceOrientation orientation = [EXScreenOrientationUtilities importOrientation:allowedOrientation];
-    UIInterfaceOrientationMask orientationMask = [EXScreenOrientationUtilities maskFromOrientation:orientation];
-    if (!orientationMask) {
-      return reject(@"ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK", @"Invalid screen orientation lock.", nil);
-    }
-                                                                         
-    allowedOrientationsMask = allowedOrientationsMask | orientationMask;
-  }
-  
-  if (![EXScreenOrientationUtilities doesDeviceSupportOrientationMask:allowedOrientationsMask]) {
-    return reject(@"ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK", @"This device does not support the requested orientation.", nil);
-  }
-  
-  [_screenOrientationRegistry setMask:allowedOrientationsMask forModule:self];
-  resolve(nil);
-}
-
-EX_EXPORT_METHOD_AS(getOrientationLockAsync,
-                    getOrientationLockAsyncWithResolver:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  resolve([EXScreenOrientationUtilities exportOrientationLock:[_screenOrientationRegistry currentOrientationMask]]);
-}
-
-EX_EXPORT_METHOD_AS(getPlatformOrientationLockAsync,
-                    getPlatformOrientationLockAsyncResolver:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  UIInterfaceOrientationMask orientationMask = [_screenOrientationRegistry currentOrientationMask];
-  NSDictionary *maskToOrienationMap = @{
-    @(UIInterfaceOrientationMaskPortrait): @(UIInterfaceOrientationPortrait),
-    @(UIInterfaceOrientationMaskPortraitUpsideDown): @(UIInterfaceOrientationPortraitUpsideDown),
-    @(UIInterfaceOrientationMaskLandscapeLeft): @(UIInterfaceOrientationLandscapeLeft),
-    @(UIInterfaceOrientationMaskLandscapeRight): @(UIInterfaceOrientationLandscapeRight)
-  };
-  // If the particular orientation is supported, we add it to the array of allowedOrientations
-  NSMutableArray *allowedOrientations = [[NSMutableArray alloc] init];
-  for (NSNumber *wrappedSingleOrientation in [maskToOrienationMap allKeys]) {
-    UIInterfaceOrientationMask supportedOrientationMask = orientationMask & [wrappedSingleOrientation intValue];
-    if (supportedOrientationMask) {
-      UIInterfaceOrientation supportedOrientation = [maskToOrienationMap[@(supportedOrientationMask)] intValue];
-      [allowedOrientations addObject:[EXScreenOrientationUtilities exportOrientation:supportedOrientation]];
-    }
-  }
-  resolve(allowedOrientations);
-}
-
-EX_EXPORT_METHOD_AS(supportsOrientationLockAsync,
-                    supportsOrientationLockAsync:(NSNumber *)orientationLock
-                    resolver:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  UIInterfaceOrientationMask orientationMask = [EXScreenOrientationUtilities importOrientationLock:orientationLock];
- 
-  if (orientationMask && [EXScreenOrientationUtilities doesDeviceSupportOrientationMask:orientationMask]) {
-    return resolve(@YES);
-  }
-  
-  resolve(@NO);
-}
-
-EX_EXPORT_METHOD_AS(getOrientationAsync,
-                    getOrientationAsyncResolver:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  resolve([EXScreenOrientationUtilities exportOrientation:[_screenOrientationRegistry currentOrientation]]);
-}
-
-// Will be called when this module's first listener is added.
-- (void)startObserving
-{
-  [_screenOrientationRegistry registerModuleToReceiveNotification:self];
-}
-
-// Will be called when this module's last listener is removed, or on dealloc.
-- (void)stopObserving
-{
-  [_screenOrientationRegistry unregisterModuleFromReceivingNotification:self];
-}
-
-- (void)screenOrientationDidChange:(UIInterfaceOrientation)orientation
-{
-  UITraitCollection * currentTraitCollection = [_screenOrientationRegistry currentTrailCollection];
-  [_eventEmitter sendEventWithName:EXScreenOrientationDidUpdateDimensions body:@{
-    @"orientationLock": [EXScreenOrientationUtilities exportOrientationLock:[_screenOrientationRegistry currentOrientationMask]],
-    @"orientationInfo": @{
-      @"orientation": [EXScreenOrientationUtilities exportOrientation:orientation],
-      @"verticalSizeClass": EXNullIfNil(@(currentTraitCollection.verticalSizeClass)),
-      @"horizontalSizeClass": EXNullIfNil(@(currentTraitCollection.horizontalSizeClass)),
-    }
-  }];
-}
-
-- (NSArray<NSString *> *)supportedEvents {
-  return @[EXScreenOrientationDidUpdateDimensions];
-}
-
-- (void)onAppBackgrounded {
-  [_screenOrientationRegistry moduleDidBackground:self];
-}
-
-- (void)onAppForegrounded {
-  [_screenOrientationRegistry moduleDidForeground:self];
-}
-
-@end

package/ios/EXScreenOrientation/EXScreenOrientationRegistry.h

@@ -1,46 +0,0 @@
-//  Copyright © 2019-present 650 Industries. All rights reserved.
-
-#import <UIKit/UIKit.h>
-#import <Foundation/Foundation.h>
-#import <ExpoModulesCore/ExpoModulesCore.h>
-#import <ExpoModulesCore/EXSingletonModule.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-@protocol EXOrientationListener <NSObject>
-
-- (void)screenOrientationDidChange:(UIInterfaceOrientation)orientation;
-
-@end
-
-@protocol EXScreenOrientationEventEmitter <NSObject>
-
-- (void)unregisterModuleFromReceivingNotification:(id<EXOrientationListener>)module;
-- (void)registerModuleToReceiveNotification:(id<EXOrientationListener>)module;
-
-@end
-
-@protocol EXScreenOrientationRegistry <NSObject>
-
-- (UIInterfaceOrientation)currentOrientation;
-- (UIInterfaceOrientationMask)currentOrientationMask;
-- (UITraitCollection *)currentTrailCollection;
-
-- (void)setMask:(UIInterfaceOrientationMask)mask forModule:(id)module;
-
-- (void)moduleDidForeground:(id)module;
-- (void)moduleDidBackground:(id)module;
-- (void)moduleWillDeallocate:(id)module;
-
-@end
-
-@interface EXScreenOrientationRegistry : EXSingletonModule <UIApplicationDelegate, EXScreenOrientationEventEmitter, EXScreenOrientationRegistry>
-
-- (void)updateCurrentScreenOrientation;
-
-- (UIInterfaceOrientationMask)requiredOrientationMask;
-- (void)traitCollectionDidChangeTo:(UITraitCollection *)traitCollection;
-
-@end
-
-NS_ASSUME_NONNULL_END