Comprehensive Solution for Locking a Single View Controller to Portrait Mode in Swift

Technical Background and Problem Analysis

In modern iOS application development, device orientation management is a common but error-prone technical aspect. Many applications need to support all device orientations for better user experience, but certain specific scenarios (such as login interfaces, video players, or game levels) may require restriction to a single orientation. Traditional global orientation control methods often perform poorly in complex view hierarchies, especially when applications contain multiple navigation controllers, tab bar controllers, or modally presented view controllers.

Core Implementation Principles

The iOS system uniformly manages application-supported orientations through the AppDelegate's supportedInterfaceOrientationsFor method. This method returns a UIInterfaceOrientationMask enumeration value that defines the allowed device orientations for the current window. The key point is that this method is called every time the device orientation might change, but the system does not automatically track which view controller is currently active.

A common erroneous approach is to determine the current controller by traversing the view hierarchy in AppDelegate. This method is not only inefficient but also prone to errors in complex view structures. A more elegant solution is to establish a global orientation locking mechanism, allowing individual view controllers to actively declare their orientation preferences when needed.

Complete Code Implementation

First, declare a global variable in AppDelegate to store the current orientation lock:

class AppDelegate: UIResponder, UIApplicationDelegate {
    
    var orientationLock = UIInterfaceOrientationMask.all
    
    func application(_ application: UIApplication, 
                     supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
        return self.orientationLock
    }
    
    // Other AppDelegate methods...
}

Next, create a global utility class to manage the orientation lock:

struct AppUtility {
    
    static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {
        if let delegate = UIApplication.shared.delegate as? AppDelegate {
            delegate.orientationLock = orientation
        }
    }
    
    static func lockOrientation(_ orientation: UIInterfaceOrientationMask, 
                                andRotateTo rotateOrientation: UIInterfaceOrientation) {
        
        self.lockOrientation(orientation)
        
        UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
        UINavigationController.attemptRotationToDeviceOrientation()
    }
    
}

View Controller Integration

In view controllers that need orientation locking, manage the orientation lock through lifecycle methods:

class SignInViewController: UIViewController {
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        // Lock to portrait mode
        AppUtility.lockOrientation(.portrait)
        
        // If simultaneous rotation to specified orientation is needed, use the following method
        // AppUtility.lockOrientation(.portrait, andRotateTo: .portrait)
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        
        // Restore all orientation support when view is disappearing
        AppUtility.lockOrientation(.all)
    }
    
    // Other view controller code...
}

Special Device Configuration

For iPad applications or universal applications, special attention must be paid to a key configuration: in the Xcode project's Target settings, ensure the "Requires full screen" option is checked. This option is located in General > Deployment Info section. If this option is not enabled, the supportedInterfaceOrientationsFor delegate method may not be called correctly, causing orientation control to fail.

Technical Details and Best Practices

1. Granularity of Orientation Lock: The above solution allows each view controller to independently manage its orientation preferences, avoiding the complexity of global state management. When presenting a login interface modally, only that controller restricts to portrait, while other interfaces maintain their original orientation support.

2. Smooth Handling of Orientation Rotation: The UIDevice.current.setValue(_:forKey:) method combined with UINavigationController.attemptRotationToDeviceOrientation() ensures smooth transitions during orientation changes. The latter notifies the system to re-evaluate current orientation constraints and triggers necessary layout updates.

3. Memory Management and State Restoration: Restoring the orientation lock in viewWillDisappear is crucial, ensuring that when users leave a specific controller, the application can resume normal orientation behavior. This method is particularly effective for navigation controller push/pop scenarios.

4. Multi-Controller Coordination: In tab bar applications, if different tabs require different orientation support, set and reset orientation locks in the viewWillAppear and viewWillDisappear methods of each tab's corresponding root controller.

Common Issues and Solutions

Issue 1: Orientation lock not taking effect in certain situations

Solution: Check if the orientation lock is set in the correct lifecycle methods. Ensure no other code (such as parent class implementations) overrides orientation settings. Verify that the "Requires full screen" configuration is correct.

Issue 2: Interface layout混乱 during orientation changes

Solution: Ensure use of Auto Layout or appropriate autoresizing masks. After orientation changes, the system automatically triggers viewWillLayoutSubviews and viewDidLayoutSubviews, where necessary layout adjustments can be made.

Issue 3: Orientation inconsistency when presenting portrait controller modally from landscape interface

Solution: Use the lockOrientation(_:andRotateTo:) method, which forces rotation to the specified orientation while locking the orientation, ensuring visual consistency.

Performance Optimization Recommendations

1. Avoid expensive computations or network requests during orientation changes.

2. For scenarios with frequent orientation switching, consider caching layout calculation results.

3. Use UIView.animate(withDuration:) to smooth interface transitions during orientation changes.

Through the above comprehensive solution, developers can precisely control the orientation behavior of each view controller in iOS applications while maintaining code clarity and maintainability. This approach based on global state and local declarations not only solves orientation management problems in complex view hierarchies but also leaves ample space for future feature expansion.