Presenting modal in iOS 13 fullscreen

Question

In iOS 13 there is a new behaviour for modal view controller when being presented.

Now it's not fullscreen by default and when I try to slide down, the app just dismiss the View Controller automatically.

How can I prevent this behaviour and get back to the old fullscreen modal vc?

Thanks

Microsporangium

Answer 1

With iOS 13, as stated in the Platforms State of the Union during the WWDC 2019, Apple introduced a new default card presentation. In order to force the fullscreen you have to specify it explicitly with:

let vc = UIViewController()
vc.modalPresentationStyle = .fullScreen //or .overFullScreen for transparency
self.present(vc, animated: true, completion: nil)

Microsporangium

I won't count on that. In the past, Apple has often changed defaults only becoming active once you are linking against the current SDK. We will hopefully get the old behavior when linking against previous versions. – Nejd

I can confirm that Xcode-10 built apps run on the iOS 13 simulator do still default to full screen. As @Nejd said, building with Xcode 11 opts the app in to the new behaviour. Use isModalInPresentation to block the swipe gesture from dismissing. See my blog post for more details: medium.com/@hacknicity/… – Gremlin

In .compact horizontal size class .fullScreen presentation does not act exactly as .formSheet in iOS 12. You should use .overFullScreen mode in order to fully replicate the old behavior. – Delossantos

I recommend to use .fullScreen instead of .overFullScreen. .fullScreen fires viewWillAppear and viewDidAppear, .overFullScreen doesn't do that – Getup

Time has passed and the .automatic style has settled down as the default one, which is (for most view controllers) .pageSheet style. However some system view controllers may map it to a different style. – Dele

No luck with this with MFMessageComposeViewController. Setting to fullScreen but it stays in the new card format. – Suppurate

How would you close this VC? – Treacherous

Keep in mind that if you use a navigation controller, the modalPresentationStyle should be added to the navigation controller, not the presented view controller. – Stoss

@JAWS007 You can call dismiss(animated: completion:), either from the VC that presents it or the VC that was presented. It will remove the topmost VC from the navigation stack. – Stoss

Answer 2

I add an information that could be useful for someone. If you have any storyboard segue, to go back to the old style, you need to set the kind property to Present Modally and the Presentation property to Full Screen.

Jeer

Is there a way in Interface Builder to set isModalInPresentation? – Alisa

You just solved my problem, thank you! 3 days of fiddling... – Stylo

Answer 3

I had this issue on the initial view right after the launch screen. The fix for me since I didn't have a segue or logic defined was to switch the presentation from automatic to fullscreen as shown here:

Heloise

Is there any way to do this programmatically for all views instead of one by one through storyboard? – Unilobed

@ShobhitPuri Have a look at the first solution by Omreyh here https://mcmap.net/q/57025/-presenting-modal-in-ios-13-fullscreen – Unilobed

Wow, this was THE answer for my issues. Thanks for the tip! For any others looking into this as well, this is the fix for strange behaviour after reopening the app from the background. In my application, opening from the background would overlay my splash screen (initial view controller) as a card presentation style and then any segues from here on out would cross-fade instead of using my defined segue style. It would be fine if I closed the app (double tap home button and swipe up, then reopen) but any additional launches would cause this strange behaviour. Thanks again! – Amend

Answer 4

There are multiple ways to do that, and I think each one could fit for one project but not another, so I thought I'll keep them here maybe someone else will run to a different case.

1- Override present

If you have a BaseViewController you can override the present(_ viewControllerToPresent: animated flag: completion:) method.

class BaseViewController: UIViewController {

  // ....

  override func present(_ viewControllerToPresent: UIViewController,
                        animated flag: Bool,
                        completion: (() -> Void)? = nil) {
    viewControllerToPresent.modalPresentationStyle = .fullScreen
    super.present(viewControllerToPresent, animated: flag, completion: completion)
  }

  // ....
}

Using this way you don't need to do any change on any present call, as we just overrode the present method.

2- An extension:

extension UIViewController {
  func presentInFullScreen(_ viewController: UIViewController,
                           animated: Bool,
                           completion: (() -> Void)? = nil) {
    viewController.modalPresentationStyle = .fullScreen
    present(viewController, animated: animated, completion: completion)
  }
}

Usage:

presentInFullScreen(viewController, animated: true)

3- For one UIViewController

let viewController = UIViewController()
viewController.modalPresentationStyle = .fullScreen
present(viewController, animated: true, completion: nil)

4- From Storyboard

Select a segue and set the presentation to FullScreen.

5- Swizzling

extension UIViewController {

  static func swizzlePresent() {

    let orginalSelector = #selector(present(_: animated: completion:))
    let swizzledSelector = #selector(swizzledPresent)

    guard let orginalMethod = class_getInstanceMethod(self, orginalSelector), let swizzledMethod = class_getInstanceMethod(self, swizzledSelector) else{return}

    let didAddMethod = class_addMethod(self,
                                       orginalSelector,
                                       method_getImplementation(swizzledMethod),
                                       method_getTypeEncoding(swizzledMethod))

    if didAddMethod {
      class_replaceMethod(self,
                          swizzledSelector,
                          method_getImplementation(orginalMethod),
                          method_getTypeEncoding(orginalMethod))
    } else {
      method_exchangeImplementations(orginalMethod, swizzledMethod)
    }

  }

  @objc
  private func swizzledPresent(_ viewControllerToPresent: UIViewController,
                               animated flag: Bool,
                               completion: (() -> Void)? = nil) {
    if #available(iOS 13.0, *) {
      if viewControllerToPresent.modalPresentationStyle == .automatic {
        viewControllerToPresent.modalPresentationStyle = .fullScreen
      }
    }
    swizzledPresent(viewControllerToPresent, animated: flag, completion: completion)
   }
}

Usage:
In your AppDelegate inside application(_ application: didFinishLaunchingWithOptions) add this line:

UIViewController.swizzlePresent()

Using this way you don't need to do any change on any present call, as we are replacing the present method implementation in runtime.
If you need to know what is swizzling you can check this link: https://nshipster.com/swift-objc-runtime/

Icarus

I have many viewControllers in my project, but do not have base class, i don't want swizzling do you have any solution for that with minimum changes in code – Slaty

I used swizzling, but I added .pageSheet to condition.... if viewControllerToPresent.modalPresentationStyle == .pageSheet || viewControllerToPresent.modalPresentationStyle == .automatic { viewControllerToPresent.modalPresentationStyle = .fullScreen } – Handicapped

status bar is hiding when I add applied solution no 1. – Lambert

Swizzling is a solution that worked great for a while. However, when using some external sdks such as FacebookLogin (5.8 as of today) and GoogleSignin, I have noticed that this method breaks those flows : we get a white screen on iPad. This is probably due to the fact that they use their own swizzling method – Blunk

Answer 5

As a hint: If you call present to a ViewController which is embedded inside a NavigationController you have to set the NavigationController to .fullScreen and not the VC.

You can do this like @davidbates or you do it programmatically (like @pascalbros).

The same applies to the UITabViewController

An example scenario for NavigationController:

    //BaseNavigationController: UINavigationController {}
    let baseNavigationController = storyboard!.instantiateViewController(withIdentifier: "BaseNavigationController")
    var navigationController = UINavigationController(rootViewController: baseNavigationController)
    navigationController.modalPresentationStyle = .fullScreen
    navigationController.topViewController as? LoginViewController
    self.present(navigationViewController, animated: true, completion: nil)

Trixie

This is a really useful point. Really easy to forget and drive you crazy (I did). Thanks – Arbuckle

Answer 6

For Objective-C users

Just Use this code

 [vc setModalPresentationStyle: UIModalPresentationFullScreen];

Or if you want to add it particular in iOS 13.0 then use

 if (@available(iOS 13.0, *)) {
     [vc setModalPresentationStyle: UIModalPresentationFullScreen];
 } else {
     // Fallback on earlier versions
 }

Romona

UIModalPresentationFullScreen works with iOS 3.2+. So no need to add if else condition. – Transect

For some reason in iOS 13.1.2 only in Obj-c classes this is not working and modalPresentationStyle is only displaying a pageSheet. Is this happening for anyone else? – Ancillary

@Ancillary I have not updated to iOS 13.1.2 but working fine at 13.1 – Romona

Answer 7

---

One Liner:

modalPresentationStyle is required to be set on the navigationController which is being presented.

---

iOS 13 and below iOS version fullScreen with overCurrentContext and navigationController

Tested Code

let controller = UIViewController()
let navigationController = UINavigationController(rootViewController: controller)
navigationController.modalPresentationStyle = .overCurrentContext
self.navigationController?.present(navigationController, animated: true, completion: nil)

modalPresentationStyle require to set at navigationController.

Hick

A clarification: presenting a viewController from a navigationController does not need modalPresentationStyle to be set on the navigationController. Instead, it is set on the viewController being presented. However, if you are presenting a navigationController, then the 'modalPresentationStyle' property should be set on the navigationController, not the embedded viewController. This approach works iOS 13.3, Xcode 11.3. See Yogesh Bharate's answer. – Decennary

Answer 8

This worked for me

let vc = self.storyboard?.instantiateViewController(withIdentifier: "storyboardID_cameraview1") as! CameraViewController
  
vc.modalPresentationStyle = .fullScreen
    
self.present(vc, animated: true, completion: nil)`

Baden

Answer 9

I used swizzling for ios 13

import Foundation
import UIKit

private func _swizzling(forClass: AnyClass, originalSelector: Selector, swizzledSelector: Selector) {
    if let originalMethod = class_getInstanceMethod(forClass, originalSelector),
       let swizzledMethod = class_getInstanceMethod(forClass, swizzledSelector) {
        method_exchangeImplementations(originalMethod, swizzledMethod)
    }
}

extension UIViewController {

    static let preventPageSheetPresentation: Void = {
        if #available(iOS 13, *) {
            _swizzling(forClass: UIViewController.self,
                       originalSelector: #selector(present(_: animated: completion:)),
                       swizzledSelector: #selector(_swizzledPresent(_: animated: completion:)))
        }
    }()

    @available(iOS 13.0, *)
    @objc private func _swizzledPresent(_ viewControllerToPresent: UIViewController,
                                        animated flag: Bool,
                                        completion: (() -> Void)? = nil) {
        if viewControllerToPresent.modalPresentationStyle == .pageSheet
                   || viewControllerToPresent.modalPresentationStyle == .automatic {
            viewControllerToPresent.modalPresentationStyle = .fullScreen
        }
        _swizzledPresent(viewControllerToPresent, animated: flag, completion: completion)
    }
}

then put this

UIViewController.preventPageSheetPresentation

somewhere

for example in AppDelegate

func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]?) -> Bool {

    UIViewController.preventPageSheetPresentation
    // ...
    return true
}

Resht

Using this we are having the below error for some devices Fatal Exception: NSInternalInconsistencyException Modifications to the layout engine must not be performed from a background thread after it has been accessed from the main thread. – Matriculate

it's weird, checkout if it happens without swizzling, (comment this line UIViewController.preventPageSheetPresentation), if it still happens find the actual issue, you call some layout somewhere in background thread (I guess in completion of network request) – Resht

Answer 10

Latest for iOS 13 and Swift 5.x

let vc = ViewController(nibName: "ViewController", bundle: nil)

vc.modalPresentationStyle = .fullScreen

self.present(vc, animated: true, completion: nil)

Prickle

Answer 11

I needed to do both:

1. Set presentation style as Full screen

2. Set Top bar as Translucent Navigation Bar

Macaroni

It's a very strange assumption that some option in Simulated Metrics helps you change presentation style – Bibbie

@AlexanderKulabukhov it doesn't. It's purely simulated. – Sororicide

Answer 12

Quick solution. There are already really great answers above. I am also adding my quick 2 points input, which is presented in the screenshot.

1. If you are not using Navigation Controller then from Right Menu Inspector set the Presentation to Full Screen

2. If you are using Navigation Controller then by default it will present full screen, you have to do nothing.

Alby

Yeap, That's pretty much it... Thanks... I don't know why the code line is not working for one particular UI, but others are working fine with the code... this seems to be the only one with storyboard though, and having code is not working issue... but when I do like this from storyboard's properties, this fixed. saved the day... – Tug

Answer 13

Here is an easy solution without coding a single line.

• Select View Controller in Storyboard
• Select attribute Inspector
• Set presentation "Automatic" to "FullScreen" as per below image

This change makes iPad app behavior as expected otherwise the new screen is displaying in the center of the screen as a popup.

Latanya

I think that what is key here is that you did this on the NavigationController, which is what the picture shows but the text does not say it this way. – Novercal

also make sure subsequent segues are "Show" and not "Present Modally" – Novercal

Ok, so this one seems to work for me when I use a tab bar controller to control other views. However, you need to set the Presentation of the actual 'Tab Bar Controller' to Full Screen as this controls all other views. – Rhee

Answer 14

Here is the solution for Objective-C

UIStoryboard *storyBoard = [UIStoryboard storyboardWithName:@"Main" bundle:nil];
ViewController *vc = [storyBoard instantiateViewControllerWithIdentifier:@"ViewController"];

vc.modalPresentationStyle = UIModalPresentationFullScreen;

[self presentViewController:vc animated:YES completion:nil];

Purificator

Answer 15

If you have a UITabController with Screens with Embeded Navigation Controllers, you have to set the UITabController Presentation to FullScreen as shown in pic below

Langlois

Answer 16

Setting navigationController.modalPresentationStyle to .fullScreen has been repeated here more than a thousand times but let me present you another blocker which was causing that UIViewController / UINavigationController was not showing in fullscreen even though all the properties were set properly.

In my case the culprit was hidden in this line

navigationController?.presentationController?.delegate = self

Apparently when setting UIAdaptivePresentationControllerDelegate you need to specify the presentation style within the optional delegate method

    public func adaptivePresentationStyle(for controller: UIPresentationController) -> UIModalPresentationStyle {
        presentationStyle
    }

Lorenzen

Answer 17

Here's my version of fix in ObjectiveC using Categories. With this approach you'll have default UIModalPresentationStyleFullScreen behaviour until another one explicitly set.

#import "UIViewController+Presentation.h"
#import "objc/runtime.h"

@implementation UIViewController (Presentation)

- (void)setModalPresentationStyle:(UIModalPresentationStyle)modalPresentationStyle {
    [self setPrivateModalPresentationStyle:modalPresentationStyle];
}

-(UIModalPresentationStyle)modalPresentationStyle {
    UIModalPresentationStyle style = [self privateModalPresentationStyle];
    if (style == NSNotFound) {
        return UIModalPresentationFullScreen;
    }
    return style;
}

- (void)setPrivateModalPresentationStyle:(UIModalPresentationStyle)modalPresentationStyle {
    NSNumber *styleNumber = [NSNumber numberWithInteger:modalPresentationStyle];
     objc_setAssociatedObject(self, @selector(privateModalPresentationStyle), styleNumber, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (UIModalPresentationStyle)privateModalPresentationStyle {
    NSNumber *styleNumber = objc_getAssociatedObject(self, @selector(privateModalPresentationStyle));
    if (styleNumber == nil) {
        return NSNotFound;
    }
    return styleNumber.integerValue;
}

@end

Bibbie

do you have the .h file? – Carousel

@PedroGóes yep, but it consist only of category declaration: ``` @interface UIViewController (Presentation) @end ``` – Bibbie

Answer 18

All the other answers are sufficient but for a large project like ours and where navigations are being made both in code and storyboard, it is quite a daunting task.

For those who are actively using Storyboard. This is my advice: use Regex.

The following format is not good for full screen pages:

<segue destination="Bof-iQ-svK" kind="presentation" identifier="importSystem" modalPresentationStyle="fullScreen" id="bfy-FP-mlc"/>

The following format is good for full screen pages:

<segue destination="7DQ-Kj-yFD" kind="presentation" identifier="defaultLandingToSystemInfo" modalPresentationStyle="fullScreen" id="Mjn-t2-yxe"/>

The following regex compatible with VS CODE will convert all Old Style pages to new style pages. You may need to escape special chars if you're using other regex engines/text editors.

Search Regex

<segue destination="(.*)"\s* kind="show" identifier="(.*)" id="(.*)"/>

Replace Regex

<segue destination="$1" kind="presentation" identifier="$2" modalPresentationStyle="fullScreen" id="$3"/>

Shedevil

Answer 19

With iOS 13, as stated in the Platforms State of the Union during the WWDC 2019, Apple introduced a new default card presentation. In order to force the fullscreen you have to specify it explicitly with:

let vc = UIViewController()
vc.modalPresentationStyle = .fullScreen //or .overFullScreen for transparency
self.navigationViewController.present(vc, animated: true, completion: nil)

Kilby

Answer 20

Initially, the default value is fullscreen for modalPresentationStyle, but in iOS 13 its changes to the UIModalPresentationStyle.automatic.

If you want to make the full-screen view controller you have to change the modalPresentationStyle to fullScreen.

Refer UIModalPresentationStyle apple documentation for more details and refer apple human interface guidelines for where should use which modality.

Vanish

This is the correct answer as of iOS 13.3, Xcode 11.3, for situations where you want to present a viewController FROM a navigationController. A modalPresentationStyle of .overFullScreen also works. However, if you are presenting a navigationController, then you need to set 'modalPresentationStyle' on the navigationController, not the viewController. Cheers. – Decennary

Answer 21

let Obj = MtViewController()
Obj.modalPresentationStyle = .overFullScreen
self.present(Obj, animated: true, completion: nil)

// if you want to disable swipe to dismiss on it, add line

Obj.isModalInPresentation = true

Check Apple Document for More info.

Sanctimony

Answer 22

You can easily do so Open your storyboard as source code and search for kind="presentation", in all the seague tag with kind = presentation add a extra attribute modalPresentationStyle="fullScreen"

Penultimate

Answer 23

I achieved it by using method swizzling(Swift 4.2):

To create an UIViewController extension as follows

extension UIViewController {

    @objc private func swizzled_presentstyle(_ viewControllerToPresent: UIViewController, animated: Bool, completion: (() -> Void)?) {

        if #available(iOS 13.0, *) {
            if viewControllerToPresent.modalPresentationStyle == .automatic || viewControllerToPresent.modalPresentationStyle == .pageSheet {
                viewControllerToPresent.modalPresentationStyle = .fullScreen
            }
        }

        self.swizzled_presentstyle(viewControllerToPresent, animated: animated, completion: completion)
    }

     static func setPresentationStyle_fullScreen() {

        let instance: UIViewController = UIViewController()
        let aClass: AnyClass! = object_getClass(instance)

        let originalSelector = #selector(UIViewController.present(_:animated:completion:))
        let swizzledSelector = #selector(UIViewController.swizzled_presentstyle(_:animated:completion:))

        let originalMethod = class_getInstanceMethod(aClass, originalSelector)
        let swizzledMethod = class_getInstanceMethod(aClass, swizzledSelector)
        if let originalMethod = originalMethod, let swizzledMethod = swizzledMethod {
        method_exchangeImplementations(originalMethod, swizzledMethod)
        }
    }
}

and in AppDelegate, in application:didFinishLaunchingWithOptions: invoke the swizzling code by calling:

UIViewController.setPresentationStyle_fullScreen()

Gaudreau

Very hacky solution. You could have achieved same result with regular UIViewController subclass and avoid swizzling. Now if I extract some screens into framework, I will not have the swizzled methods there. Needless to say this is hard to locate if you inherit the project. You should avoid swizzling like a plague. Will not give -1 as it does solve problem, but breaks SOLID as now AppDelegate is needed to configure View Controllers and can make mess in future iOS versions. – Beget

@MartinBerger , the solution will be useful if you try to migrate your old code to new and It is not recommended for the new projects. – Gaudreau

Answer 24

Create a category for UIViewController (say UIViewController+PresentationStyle). Add the following code to it.

 -(UIModalPresentationStyle)modalPresentationStyle{
     return UIModalPresentationStyleFullScreen;
}

Anchoveta

this will break UISearchController + trigger some hard to debug crash – Shanonshanta

@Shanonshanta That's a great observation. So setting the property explicitly will solve the issue. No simpler solutions if UISearchController is using. – Anchoveta

Answer 25

override modalPresentationStyle will fix the style for UIViewControllers created with or without a coder.

Advantages:

• Single place where you set it.
• No need to know which init or awake method it should be set

Disadvantage:

• You can't change it from outside like Interface builder or configuration from code

Solution:

override var modalPresentationStyle: UIModalPresentationStyle {
    get { .fullScreen }
    set { }
}

Affianced

Answer 26

an alternative approach is to have your own base viewcontroller component in your app, and just implementing the designated and required initialisers with a basic setup, something like the following:

class MyBaseViewController: UIViewController {

//MARK: Initialisers

/// Alternative initializer which allows you to set the modal presentation syle
/// - Parameter modalStyle: the presentation style to be used
init(with modalStyle:UIModalPresentationStyle) {
    super.init(nibName: nil, bundle: nil)
    self.setup(modalStyle: modalStyle)
}

override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) {
    super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
    // default modal presentation style as fullscreen
    self.setup(modalStyle: .fullScreen)
}

required init?(coder: NSCoder) {
    super.init(coder: coder)
    // default modal presentation style as fullscreen
    self.setup(modalStyle: .fullScreen)
}

//MARK: Private

/// Setup the view
///
/// - Parameter modalStyle: indicates which modal presentation style to be used
/// - Parameter modalPresentation: default true, it prevent modally presented view to be dismissible with the default swipe gesture
private func setup(modalStyle:UIModalPresentationStyle, modalPresentation:Bool = true){
    if #available(iOS 13, *) {
        self.modalPresentationStyle = modalStyle
        self.isModalInPresentation = modalPresentation
    }
}

NOTE: If your view controller is contained in a navigation controller which is actually presented modally, then the navigation controller should approach the problem in the same way (meaning, having your custom navigation controller component customised in the same way

Tested on Xcode 11.1 on iOS 13.1 and iOS 12.4

Hope it helps

Lanceted

Answer 27

The above answers and suggestions are right, below is another version, and efficient way using programmatically.

#1 Created a UIView Extension

#2 Created a Method ()

//#1
extension UIViewController {

//#2
func presentLocal(_ viewControllerToPresent: UIViewController, animated flag: 
Bool, completion: (() -> Void)? = nil) {

//Reusing below 2 lines :-)
viewControllerToPresent.modalPresentationStyle = .overCurrentContext
self.present(viewControllerToPresent, animated: flag, completion: completion)

  }
}

Invoking as below

let vc = MyViewController()
let nc = UINavigationController(rootViewController: vc)
sourceView.presentLocal(nc, animated: true, completion: nil)

OR

let vc = MyViewController()
sourceView.presentLocal(vc, animated: true, completion: nil)

Diandrous

Answer 28

class MyViewController: UIViewController {

    convenience init() {
        self.init(nibName:nil, bundle:nil)
        self.modalPresentationStyle = .fullScreen
    }

    override func viewDidLoad() {
        super.viewDidLoad()
    }
}

Rather than call self.modalPresentationStyle = .fullScreen for every view controller, you can subclass UIViewController and just use MyViewController everywhere.

Asleyaslope