Full Screen Cover: what it is, full-screen presentation and UIKit

What is Full Screen Cover in iOS?

Full Screen Cover is a modal presentation style in iOS where the presented controller occupies the entire device screen. The parent content is completely hidden, creating an immersive effect and focusing the user on the current task.

Before iOS 13, Full Screen Cover was the only modal presentation style on iPhone. All calls to present(_:animated:completion:) used .fullScreen by default. Starting with iOS 13, Apple changed the default style to .automatic, which for iPhone selects .pageSheet. However, Full Screen Cover remains available and is used for scenarios where full focus is important.

Unlike Page Sheet, Full Screen Cover does not allow interaction with parent content and does not show it under the modal window. The user cannot dismiss Full Screen Cover by swiping down — dismissal requires a programmatic call to dismiss(animated:completion:) or a close button on the screen itself. This behavior is important to consider when designing UX.

Full Screen Cover vs Page Sheet: style comparison

Page Sheet is the second main modal presentation style, introduced in iOS 13. Page Sheet displays as a card with a top inset, beneath which the parent screen is visible. The user can dismiss Page Sheet by swiping down. Full Screen Cover, on the contrary, hides the parent content and does not support swipe dismissal.

The choice between Full Screen Cover and Page Sheet depends on the content and context. It is recommended to use Full Screen Cover for content that requires full attention: full-screen video, photo preview, document scanning. Page Sheet is for tasks where the parent screen context is important: editing forms, option selection, detail views.

UIKit implementation: UIModalPresentationStyle

UIKit provides the UIModalPresentationStyle.fullScreen constant for setting the modal presentation style. Setting this property on UIViewController before calling present ensures the controller displays in full screen. The controller also manages behavior when the keyboard appears and handles system events.

Configuration and Delegate

After setting the .fullScreen style, it is recommended to configure presentationController?.delegate to handle dismissal events. The UIAdaptivePresentationControllerDelegate delegate allows intercepting dismissal attempts and preventing data loss. Unlike Page Sheet, for Full Screen Cover the delegate only fires on programmatic dismiss calls.

Rotation and Keyboard Handling

Full Screen Cover correctly handles screen rotation and keyboard appearance. When rotated, the modal controller automatically adapts to the new orientation. UIKeyboardWillShowNotification allows shifting content up when the keyboard appears, keeping text fields visible. Unlike Page Sheet, Full Screen Cover does not change its size when the keyboard appears.

let playerVC = VideoPlayerViewController()
playerVC.modalPresentationStyle = .fullScreen
playerVC.modalTransitionStyle = .crossDissolve
present(playerVC, animated: true) {
    playerVC.startPlayback()
}

// Dismiss
dismiss(animated: true) {
    print("Player dismissed")
}

SwiftUI: the .fullScreenCover modifier

SwiftUI provides the .fullScreenCover modifier for declarative creation of full-screen modal windows. Unlike .sheet (Page Sheet), .fullScreenCover creates the .fullScreen style with similar behavior: full content coverage and no swipe dismissal.

Usage with Binding and Data

The modifier accepts a binding to Bool or an optional identifiable item. When the binding is set to true, SwiftUI animates the appearance of the full-screen window. The onDismiss parameter and a content closure are used for data passing. The \.dismiss environment value allows dismissing the modal window from within.

Full Screen Cover vs Sheet

The choice between .fullScreenCover and .sheet in SwiftUI is analogous to UIKit: .fullScreenCover for immersive content, .sheet for cards. SwiftUI automatically selects the correct dismissal behavior: .sheet can be dismissed by swipe, .fullScreenCover only programmatically. Modifiers can be combined in a single View hierarchy.

struct CameraView: View {
    @State private var showCamera = false

    var body: some View {
        Button("Open Camera") {
            showCamera = true
        }
        .fullScreenCover(isPresented: $showCamera) {
            CameraPreviewView()
                .ignoresSafeArea()
        }
    }
}

struct CameraPreviewView: View {
    @Environment(\.dismiss) private var dismiss

    var body: some View {
        ZStack {
            Color.black.ignoresSafeArea()
            VStack {
                Spacer()
                Button("Capture") { dismiss() }
                    .foregroundColor(.white)
            }
        }
    }
}

Custom animations and transitions

Full Screen Cover supports custom animations through UIModalTransitionStyle in UIKit and custom transitions in SwiftUI. Standard styles include: .coverVertical (bottom to top), .crossDissolve (fade in), .flipHorizontal (flip), and .partialCurl (page curl effect).

UIKit: UIViewControllerAnimatedTransitioning

For fully custom animation, implement the UIViewControllerAnimatedTransitioning protocol. It allows defining the animation duration and the transition itself via the animateTransition(using:) method. The animation controller is assigned through UINavigationControllerDelegate or UIViewControllerTransitioningDelegate.

SwiftUI: Matched Geometry Effect

In SwiftUI, custom transitions for .fullScreenCover are created using matchedGeometryEffect. This modifier animates the movement of an element from the parent View to the full-screen window. For example, when tapping a photo thumbnail, it smoothly expands to full screen, creating a continuity effect. MatchedGeometryEffect works with id and namespace that link elements in the source and target positions.

struct PhotoViewer: View {
    @State private var selectedPhoto: String?
    @Namespace private var animation

    var body: some View {
        HStack {
            ForEach(["photo1", "photo2"], id: \.self) { photo in
                Image(photo)
                    .matchedGeometryEffect(id: photo, in: animation)
                    .onTapGesture { selectedPhoto = photo }
            }
        }
        .fullScreenCover(item: $selectedPhoto) { photo in
            Image(photo)
                .matchedGeometryEffect(id: photo, in: animation)
                .ignoresSafeArea()
        }
    }
}

When to use Full Screen Cover?

Full Screen Cover is recommended for scenarios where content should occupy the entire screen without distraction from the parent interface. Apple HIG identifies three main categories: media content, content creation tools, and temporary system interfaces.

Media and Entertainment

Video players, photo viewing, PDF and comic reading are typical use cases for Full Screen Cover. AVPlayerViewController in iOS automatically uses full-screen mode when transitioning to landscape. Photo editors like Adobe Lightroom open a full-screen editor above the photo library.

Content Creation Tools

Camera, document scanner, voice recording — tasks requiring the user's full attention. UIImagePickerController used Full Screen Cover for the camera before iOS 14. Starting with iOS 14, the system picker uses Page Sheet, but the developer can force .fullScreen for a custom camera.

What to Avoid

Do not use Full Screen Cover for: registration forms (Page Sheet is preferred), screens with text input where parent page context is important, and sequential navigation inside the modal window. Material Design also recommends avoiding blocking the system back button — this is acceptable in iOS, but the user should have a clear way to dismiss via a UI element.