I have a SwiftUI application in development, and for most screens, I'm fine with them being either landscape or portrait, and making designs for each orientation. However, for some screens, I would like to only allow the portrait orientation, and a few in only landscape. Essentially, something like the following StackOverflow post, but for SwiftUI:
https://stackoverflow.com/questions/25606442/how-to-lock-portrait-orientation-for-only-main-view-using-swift
Anything like this for SwiftUI yet?
This would make for a good bug report, because Apple could so easily build this into SwiftUI. Still, after some experimenting and pulling of hair, I have a solution for you.
UIViewControllersupportedInterfaceOrientationsUIHostingControllerUIHostingControllerUIHostingControllerNext, you need a way of propagating it from your lower views. Happily, SwiftUI has our backs here, and we can define a type conforming to
PreferenceKey.preference().onPreferenceChanged()PreferenceKeyUIInterfaceOrientationMaskOptionSetformIntersection()Now, you need a
ViewonPreferenceChange()super.init(rootView:)rootView.onPreferenceChange()onPreferenceChange()UIHostingControllerSo, what I settled on was a box type—a class (reference) type containing a value. The initializer of the new root controller creates one on the stack and passes it down into a special generic view that wraps the input
rootViewonPreferenceChange()super.init()Root<Content>Lastly, a custom method in a
View.supportedOrientations()SceneDelegate.Here's the code:
import SwiftUI
struct SupportedOrientationsPreferenceKey: PreferenceKey {
typealias Value = UIInterfaceOrientationMask
static var defaultValue: UIInterfaceOrientationMask {
if UIDevice.current.userInterfaceIdiom == .pad {
return .all
}
else {
return .allButUpsideDown
}
}
static func reduce(value: inout UIInterfaceOrientationMask, nextValue: () -> UIInterfaceOrientationMask) {
// use the most restrictive set from the stack
value.formIntersection(nextValue())
}
}
/// Use this in place of `UIHostingController` in your app's `SceneDelegate`.
///
/// Supported interface orientations come from the root of the view hierarchy.
class OrientationLockedController<Content: View>: UIHostingController<OrientationLockedController.Root<Content>> {
class Box {
var supportedOrientations: UIInterfaceOrientationMask
init() {
self.supportedOrientations =
UIDevice.current.userInterfaceIdiom == .pad
? .all
: .allButUpsideDown
}
}
var orientations: Box!
override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
orientations.supportedOrientations
}
init(rootView: Content) {
let box = Box()
let orientationRoot = Root(contentView: rootView, box: box)
super.init(rootView: orientationRoot)
self.orientations = box
}
@objc required dynamic init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
struct Root<Content: View>: View {
let contentView: Content
let box: Box
var body: some View {
contentView
.onPreferenceChange(SupportedOrientationsPreferenceKey.self) { value in
// Update the binding to set the value on the root controller.
self.box.supportedOrientations = value
}
}
}
}
extension View {
func supportedOrientations(_ supportedOrientations: UIInterfaceOrientationMask) -> some View {
// When rendered, export the requested orientations upward to Root
preference(key: SupportedOrientationsPreferenceKey.self, value: supportedOrientations)
}
}
struct ContentView: View {
var body: some View {
Text("Hello, World!")
.supportedOrientations(.portrait)
}
}
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView()
}
}Meanwhile, in SceneDelegate.swift:
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
// Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
// If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
// This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
// Create the SwiftUI view that provides the window contents.
let contentView = ContentView()
// Use a UIHostingController as window root view controller.
if let windowScene = scene as? UIWindowScene {
let window = UIWindow(windowScene: windowScene)
window.rootViewController = OrientationLockedController(rootView: contentView)
self.window = window
window.makeKeyAndVisible()
}
}Now fire up the iPhone or iPad simulator and start rotating!
