feat: add onDisplayChanged event (listenForDisplayChanges)

README.md

@@ -130,6 +130,21 @@ func application(_ application: UIApplication, supportedInterfaceOrientationsFor
 
 ```
 
+Starting from iOS 27, `application(_:supportedInterfaceOrientationsFor:)` is deprecated in favor of
+`UIWindowSceneDelegate.supportedInterfaceOrientations(for:)`. The AppDelegate method above still works, but if your
+app adopts the UIScene lifecycle and you build with the iOS 27 SDK, you can implement the new method in your
+SceneDelegate instead:
+
+```swift
+
+import OrientationDirector
+
+func supportedInterfaceOrientations(for windowScene: UIWindowScene) -> UIInterfaceOrientationMask {
+  return SharedOrientationDirectorImpl.shared.supportedInterfaceOrientations
+}
+
+```
+
 If you need help, you can check the example project.
 
 ## Usage
@@ -147,6 +162,7 @@ This library exports a class called: [RNOrientationDirector](https://github.com/
 | 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   |
+| listenForDisplayChanges                  | Triggers a provided callback each time the app moves to a different display       |
 | convertOrientationToHumanReadableString  | Returns a human readable string based on the given orientation                    |
 | convertAutoRotationToHumanReadableString | Returns a human readable string based on the given auto rotation                  |
 | setHumanReadableOrientations             | Sets the mapping needed to convert orientation values to human readable strings   |
@@ -184,6 +200,30 @@ documentation:
 2. [iOS - UIDeviceOrientation](https://developer.apple.com/documentation/uikit/uideviceorientation)
 3. [Android - getRotation](<https://developer.android.com/reference/android/view/Display#getRotation()>)
 
+### iOS
+
+Starting from iOS 16, the interface orientation is read from the window scene geometry, which reflects what the
+system actually displays. As a consequence, after calling `lockTo` or `resetSupportedInterfaceOrientations` the new
+interface orientation is delivered through the listeners (and hooks) as soon as the system applies it, instead of
+being assumed right away.
+
+#### Foldable devices (iPhone Duo)
+
+On foldable devices the app moves between the outer and the inner display when the device is folded or unfolded:
+
+1. The interface orientation is updated on fold / unfold, even though the device itself is not rotated;
+2. The device orientation is the one reported by iOS (`UIDevice.orientation`), which is relative to the device body
+   and does not change on fold / unfold. The iPhone Duo inner display is mounted rotated by 90° relative to the
+   body, so an unfolded device can report a `portrait` device orientation together with a landscape interface
+   orientation, exactly like a native app would read them;
+3. The inner display is a resizable environment: iOS treats the supported interface orientations as a preference and
+   ignores them there. This means that `lockTo` has no effect on the inner display, while it keeps working on the
+   outer one. `isLocked` still reports whether a lock has been requested, and the interface orientation always
+   reports the orientation actually displayed.
+
+To be notified when the app moves to another display (e.g. fold / unfold), use `listenForDisplayChanges`: the
+orientation values alone might not change in that case.
+
 ### Android
 
 Since on Android we need to deal with sensors and their usage, it is worth noting that the device orientation computation works

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

@@ -73,6 +73,14 @@ class OrientationDirectorModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun sendOnDisplayChanged(params: WritableMap) {
+    try {
+      emitOnDisplayChanged(params)
+    } catch(_: Exception) {
+      // No listener instance yet
+    }
+  }
+
   companion object {
     const val NAME = OrientationDirectorModuleImpl.NAME
   }

android/src/main/java/com/orientationdirector/implementation/DisplayChangesListener.kt

@@ -0,0 +1,106 @@
+package com.orientationdirector.implementation
+
+import android.content.Context
+import android.graphics.Point
+import android.hardware.display.DisplayManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.view.WindowManager
+import com.facebook.react.bridge.ReactApplicationContext
+
+/**
+ * Notifies when the app moves to a display with a different physical size,
+ * e.g. when a foldable device is folded or unfolded.
+ *
+ * DisplayManager notifies any display change, rotations included, so the
+ * physical size is compared regardless of its orientation.
+ */
+class DisplayChangesListener internal constructor(private val context: ReactApplicationContext) :
+  DisplayManager.DisplayListener {
+
+  private val displayManager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+  private val handler = Handler(Looper.getMainLooper())
+  private var isRegistered = false
+  private var lastPhysicalSize: Pair<Int, Int>? = null
+
+  private var onDisplayChangedCallback: ((widthDp: Double, heightDp: Double) -> Unit)? = null
+
+  fun setOnDisplayChangedCallback(callback: (widthDp: Double, heightDp: Double) -> Unit) {
+    onDisplayChangedCallback = callback
+  }
+
+  fun register() {
+    if (isRegistered) {
+      return
+    }
+
+    displayManager.registerDisplayListener(this, handler)
+    isRegistered = true
+
+    // The display might have changed while the listener was unregistered
+    checkDisplay()
+  }
+
+  fun unregister() {
+    if (!isRegistered) {
+      return
+    }
+
+    displayManager.unregisterDisplayListener(this)
+    isRegistered = false
+  }
+
+  override fun onDisplayAdded(displayId: Int) = Unit
+
+  override fun onDisplayRemoved(displayId: Int) = Unit
+
+  override fun onDisplayChanged(displayId: Int) {
+    checkDisplay()
+  }
+
+  private fun checkDisplay() {
+    val size = computeDisplaySize() ?: return
+    val physicalSize = Pair(minOf(size.x, size.y), maxOf(size.x, size.y))
+
+    val previousPhysicalSize = lastPhysicalSize
+    lastPhysicalSize = physicalSize
+
+    // First sync, nothing changed yet
+    if (previousPhysicalSize == null || previousPhysicalSize == physicalSize) {
+      return
+    }
+
+    val density = computeDensity()
+    onDisplayChangedCallback?.invoke(size.x / density, size.y / density)
+  }
+
+  /**
+   * Returns the size of the display the activity is on, in pixels,
+   * in the orientation it is currently displayed.
+   */
+  private fun computeDisplaySize(): Point? {
+    val activity = context.currentActivity ?: return null
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      val bounds = activity.windowManager.maximumWindowMetrics.bounds
+      return Point(bounds.width(), bounds.height())
+    }
+
+    val windowManager = activity.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+    val size = Point()
+    @Suppress("DEPRECATION")
+    windowManager.defaultDisplay.getRealSize(size)
+    return size
+  }
+
+  private fun computeDensity(): Double {
+    val activity = context.currentActivity
+
+    if (activity != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      return activity.windowManager.maximumWindowMetrics.density.toDouble()
+    }
+
+    return (activity?.resources ?: context.resources).displayMetrics.density.toDouble()
+  }
+}

android/src/main/java/com/orientationdirector/implementation/EventManager.kt

@@ -27,6 +27,14 @@ class EventManager(private val delegate: EventManagerDelegate) {
     delegate.sendOnLockChanged(params)
   }
 
+  fun sendDisplayDidChange(width: Double, height: Double) {
+    val params = Arguments.createMap().apply {
+      putDouble("width", width)
+      putDouble("height", height)
+    }
+    delegate.sendOnDisplayChanged(params)
+  }
+
   companion object {
     const val NAME = "OrientationEventManager"
   }

android/src/main/java/com/orientationdirector/implementation/EventManagerDelegate.kt

@@ -6,4 +6,5 @@
        fun sendOnDeviceOrientationChanged(params: WritableMap)
        fun sendOnInterfaceOrientationChanged(params: WritableMap)
        fun sendOnLockChanged(params: WritableMap)
+       fun sendOnDisplayChanged(params: WritableMap)
    }

android/src/main/java/com/orientationdirector/implementation/OrientationDirectorModuleImpl.kt

@@ -16,6 +16,7 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
   )
   private var mLifecycleListener = LifecycleListener()
   private var mBroadcastReceiver = ConfigurationChangedBroadcastReceiver(context)
+  private var mDisplayChangesListener = DisplayChangesListener(context)
 
   private var initialSupportedInterfaceOrientations = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
   private var lastInterfaceOrientation = Orientation.UNKNOWN
@@ -36,6 +37,10 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
       checkInterfaceOrientation(false)
     }
 
+    mDisplayChangesListener.setOnDisplayChangedCallback { width, height ->
+      mEventManager.sendDisplayDidChange(width, height)
+    }
+
     // NOTE(1.init): This is needed to compute the initial device orientation
     mOrientationSensorsEventListener.enable()
 
@@ -46,20 +51,23 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
       }
       mAutoRotationObserver.enable()
       mBroadcastReceiver.register()
+      mDisplayChangesListener.register()
     }
     mLifecycleListener.setOnHostPauseCallback {
       if (!didComputeInitialDeviceOrientation || areOrientationSensorsEnabled) {
         mOrientationSensorsEventListener.disable()
       }
       mAutoRotationObserver.disable()
       mBroadcastReceiver.unregister()
+      mDisplayChangesListener.unregister()
     }
     mLifecycleListener.setOnHostDestroyCallback {
       if (!didComputeInitialDeviceOrientation || areOrientationSensorsEnabled) {
         mOrientationSensorsEventListener.disable()
       }
       mAutoRotationObserver.disable()
       mBroadcastReceiver.unregister()
+      mDisplayChangesListener.unregister()
     }
 
     initialSupportedInterfaceOrientations =

example/src/screens/Explore.tsx

@@ -1,3 +1,4 @@
+import { useEffect, useState } from 'react';
 import { Button, Text, View } from 'react-native';
 import { exploreStyle } from './styles';
 import RNOrientationDirector, {
@@ -13,6 +14,16 @@ function Explore() {
   const interfaceOrientation = useInterfaceOrientation();
   const deviceOrientation = useDeviceOrientation();
   const isInterfaceOrientationLocked = useIsInterfaceOrientationLocked();
+  const [lastDisplayChange, setLastDisplayChange] = useState<string>('None');
+
+  useEffect(() => {
+    const subscription = RNOrientationDirector.listenForDisplayChanges(
+      ({ width, height }) => {
+        setLastDisplayChange(`${Math.round(width)}x${Math.round(height)}`);
+      }
+    );
+    return () => subscription.remove();
+  }, []);
 
   const handleGoToInnerExploreOnPress = () => {
     navigation.navigate('InnerExplore' as never);
@@ -44,6 +55,9 @@ function Explore() {
           Is Interface Orientation Locked:
           {isInterfaceOrientationLocked ? 'Yes' : 'No'}
         </Text>
+        <Text style={[exploreStyle.text, exploreStyle.marginBottom]}>
+          Last Display Change:{lastDisplayChange}
+        </Text>
       </View>
     </View>
   );

ios/OrientationDirector.mm

@@ -69,6 +69,14 @@ -(void)emitOnLockChangedWithParams:(NSDictionary*)params {
   }
 }
 
+-(void)emitDisplayChangedWithParams:(NSDictionary*)params {
+  try {
+    [self emitOnDisplayChanged:params];
+  } catch (std::exception &e) {
+    // Ignore if no listeners
+  }
+}
+
 ///
 ///////////////////////////////////////////////////////////////////////////////////////
 

ios/implementation/EventManager.swift

@@ -36,10 +36,20 @@ public class EventManager: NSObject {
         let params = Dictionary(dictionaryLiteral: ("locked", value))
         delegate.emitOnLockChanged(params: params as NSDictionary)
     }
+
+    func sendDisplayDidChange(size: CGSize) {
+        guard let delegate = delegate else {
+            return
+        }
+
+        let params: [String: Any] = ["width": size.width, "height": size.height]
+        delegate.emitDisplayChanged(params: params as NSDictionary)
+    }
 }
 
 @objc public protocol OrientationEventEmitterDelegate {
     func emitOnLockChanged(params: NSDictionary)
     func emitDeviceOrientationChanged(params: NSDictionary)
     func emitInterfaceOrientationChanged(params: NSDictionary)
+    func emitDisplayChanged(params: NSDictionary)
 }