Merge pull request #162 from ififi2017/fix/ios-scene-aware-orientation

fix(ios): make the QA orientation hook actually turn the window

Author: ififi2017

AGENTS.md

@@ -426,9 +426,15 @@ orientation is reported as a miss with the reason, because a screenshot of the
 Home Screen is a perfectly valid PNG. `IOS_QA_SCENES`, `IOS_QA_THEME=both`,
 `IOS_QA_LANGUAGE`, `IOS_QA_IPHONE` / `IOS_QA_IPAD` and `IOS_QA_SKIP_BUILD=1`
 narrow or redirect it; it builds into its own DerivedData so it never fights
-Xcode. Known gap: the `qaOrientation` landscape hook does not currently rotate,
-so those columns report "still portrait" until it is fixed — the app writes the
-reason to `ios.native.qaOrientationError`.
+Xcode. The `qaOrientation` hook goes through `AppOrientationPolicy`, which pins
+the requested mask before asking for the geometry update: requesting landscape
+on its own does not hold, because iOS re-reads the root controller's
+`supportedInterfaceOrientations`, still sees portrait allowed, and turns a
+physically portrait simulator straight back — that is what made those columns
+report "still portrait". A pin lasts the life of the process, so it belongs
+only in the DEBUG build. The app writes any geometry error to
+`ios.native.qaOrientationError`. The fix has not yet been confirmed by a full
+sweep; re-run one before trusting the landscape columns.
 
 `npm run check:ios` guards the shipping configuration of that project — bundle
 ids against Universal Purchase, the SwiftUI entry point, iPhone/iPad

src-mobile/ios/App/App/AppDelegate.swift

@@ -74,14 +74,52 @@ final class AppOrientationPolicy {
         }
     }
 
+    /// The mask the policy should be reporting, given first-run state and any
+    /// orientation a QA screenshot run has pinned.
+    ///
+    /// A pin outranks the ordinary policy for the life of the process. Without
+    /// that, the next `.active` transition would hand the policy back and turn
+    /// the window away from the orientation the sweep asked for.
+    static func resolvedMask(
+        onboardingComplete: Bool,
+        qaPinned: UIInterfaceOrientationMask?
+    ) -> UIInterfaceOrientationMask {
+        qaPinned ?? mask(onboardingComplete: onboardingComplete)
+    }
+
     func update(onboardingComplete: Bool) {
-        let requested = Self.mask(onboardingComplete: onboardingComplete)
+        let requested = Self.resolvedMask(
+            onboardingComplete: onboardingComplete,
+            qaPinned: qaPinnedOrientations
+        )
         let changed = supportedOrientations != requested
         supportedOrientations = requested
         RootOrientationSwizzle.installOnKeyWindow()
         applyToWindows(forceGeometryUpdate: changed)
     }
 
+#if DEBUG
+    private var qaPinnedOrientations: UIInterfaceOrientationMask?
+
+    /// Turns the window for a QA screenshot run and keeps it turned.
+    ///
+    /// `requestGeometryUpdate` on its own does not hold. iOS re-reads the root
+    /// controller's `supportedInterfaceOrientations` the moment the request
+    /// lands, and while that still answers `.allButUpsideDown` the physically
+    /// portrait simulator wins and the window turns straight back — which is
+    /// why every landscape column of the sweep came back "still portrait".
+    /// Narrowing the policy to the requested orientation first is what makes
+    /// the turn stick.
+    func pinOrientationsForQA(_ mask: UIInterfaceOrientationMask) {
+        qaPinnedOrientations = mask
+        supportedOrientations = mask
+        RootOrientationSwizzle.installOnKeyWindow()
+        applyToWindows(forceGeometryUpdate: true)
+    }
+#else
+    private var qaPinnedOrientations: UIInterfaceOrientationMask? { nil }
+#endif
+
     private func applyToWindows(forceGeometryUpdate: Bool) {
         let mask = supportedOrientations
         for scene in UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }) {
@@ -98,6 +136,13 @@ final class AppOrientationPolicy {
                     orientationLog.error(
                         "Geometry update failed: \(error.localizedDescription, privacy: .public)"
                     )
+#if DEBUG
+                    // The screenshot sweep reads this key to explain a miss.
+                    UserDefaults.standard.set(
+                        error.localizedDescription,
+                        forKey: "ios.native.qaOrientationError"
+                    )
+#endif
                 }
             }
         }

src-mobile/ios/App/App/Native/Services/ShareSheet.swift

@@ -50,11 +50,15 @@ enum SystemShare {
     /// sidesteps that entirely.
     @MainActor
     static func present(items: [Any]) {
+        // `connectedScenes` is unordered, so falling straight back to `.first`
+        // could hand the sheet a backgrounded iPad window and put it up where
+        // the user is not looking. Same ordering as `manageSubscriptions`:
+        // on screen and active, then on screen, then anything at all.
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
         guard
-            let scene = UIApplication.shared.connectedScenes
-                .compactMap({ $0 as? UIWindowScene })
-                .first(where: { $0.activationState == .foregroundActive })
-                ?? UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }).first,
+            let scene = scenes.first(where: { $0.activationState == .foregroundActive })
+                ?? scenes.first(where: { $0.activationState == .foregroundInactive })
+                ?? scenes.first,
             let root = scene.windows.first(where: \.isKeyWindow)?.rootViewController
         else { return }
 

src-mobile/ios/App/App/Native/Views/RootView.swift

@@ -301,11 +301,11 @@ struct OffWorkCountdownRootView: View {
         defaults.removeObject(forKey: "ios.native.qaOrientationError")
         let orientations: UIInterfaceOrientationMask = requested == "landscape" ? .landscape : .portrait
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) {
-            guard let scene = UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }).first else { return }
-            scene.windows.first?.rootViewController?.setNeedsUpdateOfSupportedInterfaceOrientations()
-            scene.requestGeometryUpdate(.iOS(interfaceOrientations: orientations)) { error in
-                UserDefaults.standard.set(error.localizedDescription, forKey: "ios.native.qaOrientationError")
-            }
+            // The policy owns every window of every connected scene. Reaching
+            // for `connectedScenes.first` here turned whichever scene the
+            // system happened to hand back first, which on an iPad running
+            // Stage Manager is not necessarily the one being photographed.
+            AppOrientationPolicy.shared.pinOrientationsForQA(orientations)
         }
 #endif
     }

src-mobile/ios/App/AppTests/OffWorkStoreTests.swift

@@ -2758,6 +2758,37 @@ func orientationPolicyUnlocksAfterOnboarding() {
     #expect(unlocked.contains(.landscapeRight))
 }
 
+@MainActor
+@Test("A QA orientation pin outranks the ordinary policy")
+func qaOrientationPinOutranksPolicy() {
+    // The screenshot sweep asks for landscape and then the app becomes active,
+    // which re-runs `update(onboardingComplete:)`. While that handed back
+    // `.allButUpsideDown`, iOS re-read it, saw the simulator was physically
+    // portrait, and turned the window back — every landscape column of the
+    // sweep came out "still portrait".
+    let pinned = AppOrientationPolicy.resolvedMask(
+        onboardingComplete: true,
+        qaPinned: .landscape
+    )
+    #expect(pinned == .landscape)
+    #expect(!pinned.contains(.portrait))
+
+    // A pin also holds through first-run, where the policy wants portrait only.
+    #expect(
+        AppOrientationPolicy.resolvedMask(onboardingComplete: false, qaPinned: .landscape)
+            == .landscape
+    )
+
+    // With nothing pinned the policy is unchanged.
+    #expect(
+        AppOrientationPolicy.resolvedMask(onboardingComplete: false, qaPinned: nil) == .portrait
+    )
+    #expect(
+        AppOrientationPolicy.resolvedMask(onboardingComplete: true, qaPinned: nil)
+            == AppOrientationPolicy.mask(onboardingComplete: true)
+    )
+}
+
 @MainActor
 @Test("A warm session remembers the shift-end celebration")
 func celebrationSurvivesWarmSession() throws {