Présentation du modal dans iOS 13 en plein écran

Dans iOS 13, il existe un nouveau comportement pour le contrôleur de vue modale lors de sa présentation.

Maintenant, ce n'est pas plein écran par défaut et lorsque j'essaie de glisser vers le bas, l'application ferme simplement le contrôleur de vue automatiquement.

Comment puis-je empêcher ce comportement et revenir à l'ancien vc modal plein écran?

Merci

Avec iOS 13, comme indiqué dans l' état des plates - formes de l'Union lors de la WWDC 2019, Apple a introduit une nouvelle présentation de carte par défaut. Pour forcer le plein écran, vous devez le spécifier explicitement avec:

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

J'ajoute une information qui pourrait être utile à quelqu'un. Si vous avez une séquence de storyboard, pour revenir à l'ancien style, vous devez définir la propriété kind sur Present Modally et la propriété Presentation sur Full Screen .

J'ai eu ce problème sur la vue initiale juste après l'écran de lancement. Le correctif pour moi puisque je n'avais pas de séquence ou de logique définie était de basculer la présentation de l'automatique au plein écran comme indiqué ici:

Il y a plusieurs façons de le faire, et je pense que chacun pourrait convenir à un projet mais pas à un autre, alors j'ai pensé que je les garderais ici, peut-être que quelqu'un d'autre ira dans un cas différent.

1- Priorité présente

Si vous en avez un, BaseViewControllervous pouvez remplacer la present(_ viewControllerToPresent: animated flag: completion:)méthode.

class BaseViewController: UIViewController {

  // ....

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

  // ....
}

De cette façon, vous n'avez pas besoin de faire de changement sur aucun presentappel, car nous avons simplement dépassé lepresent méthode.

2- Une 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- Pour un UIViewController

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

4- Du Storyboard

Sélectionnez une séquence et définissez la présentation sur 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)
   }
}

Utilisation:
Dans votre AppDelegateintérieur, application(_ application: didFinishLaunchingWithOptions)ajoutez cette ligne:

UIViewController.swizzlePresent()

De cette façon, vous n'avez pas besoin de faire de changement sur un appel en cours, car nous remplaçons l'implémentation de la méthode actuelle dans le runtime.
Si vous avez besoin de savoir ce qui se passe, vous pouvez consulter ce lien: https://nshipster.com/swift-objc-runtime/

J'ai utilisé swizzling pour 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)
    }
}

puis mettez ça

UIViewController.preventPageSheetPresentation

quelque part

par exemple dans AppDelegate

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

    UIViewController.preventPageSheetPresentation
    // ...
    return true
}

Pour les utilisateurs d'Objective-C

Utilisez simplement ce code

 [vc setModalPresentationStyle: UIModalPresentationFullScreen];

Ou si vous souhaitez l'ajouter en particulier dans iOS 13.0, utilisez

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

Bon mot:

modalPresentationStyledoit être défini sur le navigationController qui est présenté .

iOS 13 et versions ultérieures iOS fullScreen avec overCurrentContextet navigationController

Code testé

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

modalPresentationStyle nécessite de définir à navigationController .

À titre indicatif: si vous appelez present à un ViewControllerqui est intégré dans un, NavigationControllervous devez définir le NavigationControllerto .fullScreenet non le VC.

Vous pouvez le faire comme @davidbates ou vous le faites par programme (comme @pascalbros).

Un exemple de scénario:

    //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)

Je devais faire les deux:

1. Définir le style de présentation en plein écran

   

2. Définir la barre supérieure comme barre de navigation translucide

Changer modalPresentationStyleavant de présenter

vc.modalPresentationStyle = UIModalPresentationFullScreen;

Voici une solution simple sans coder une seule ligne.

• Sélectionnez Afficher le contrôleur dans le Storyboard
• Sélectionner un inspecteur d'attributs
• Réglez la présentation "Automatique" sur "Plein écran" comme sur l'image ci-dessous

Cette modification rend le comportement de l'application iPad comme prévu, sinon le nouvel écran s'affiche au centre de l'écran sous forme de popup.

Si vous avez un UITabController avec des écrans avec des contrôleurs de navigation intégrés, vous devez définir la présentation UITabController sur FullScreen comme indiqué dans l'image ci-dessous

Voici la solution pour Objective-C

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

vc.modalPresentationStyle = UIModalPresentationFullScreen;

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

Dernière version pour iOS 13 et Swift 5.x

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

vc.modalPresentationStyle = .fullScreen

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

Voici ma version de correctif dans ObjectiveC en utilisant les catégories. Avec cette approche, vous aurez le comportement UIModalPresentationStyleFullScreen par défaut jusqu'à ce qu'un autre soit défini explicitement.

#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

Toutes les autres réponses sont suffisantes, mais pour un grand projet comme le nôtre et où les navigations sont effectuées à la fois dans le code et le storyboard, c'est une tâche assez intimidante.

Pour ceux qui utilisent activement Storyboard. Voici mon conseil: utilisez Regex.

Le format suivant n'est pas adapté aux pages plein écran:

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

Le format suivant convient aux pages plein écran:

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

Le regex suivant compatible avec VS CODE convertira toutes les pages de l'ancien style en nouvelles pages de style. Vous devrez peut-être échapper des caractères spéciaux si vous utilisez d'autres moteurs / éditeurs de texte regex.

Rechercher Regex

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

Remplacer Regex

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

Initialement, la valeur par défaut est fullscreenpour modalPresentationStyle, mais dans iOS 13 ses modifications dans UIModalPresentationStyle.automatic.

Si vous souhaitez créer le contrôleur de vue plein écran, vous devez changer le modalPresentationStyleen fullScreen.

Reportez-vous à UIModalPresentationStyle la documentation Apple pour plus de détails et reportez-vous aux directives de l'interface humaine Apple pour savoir où utiliser quelle modalité.

Vous pouvez facilement le faire Ouvrez votre storyboard en tant que code source et recherchez kind="presentation", dans toutes les balises seague avec kind = presentation ajoutez un attribut supplémentairemodalPresentationStyle="fullScreen"

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

// si vous souhaitez désactiver le glissement pour le supprimer, ajoutez une ligne

Obj.isModalInPresentation = true

Consultez le document Apple pour plus d'informations.

Je l'ai atteint en utilisant la méthode swizzling (Swift 4.2):

Pour créer une extension UIViewController comme suit

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)
        }
    }
}

et dans AppDelegate, dans l'application: didFinishLaunchingWithOptions: invoquez le code swizzling en appelant:

UIViewController.setPresentationStyle_fullScreen()

Cela a fonctionné pour moi:

yourViewController.modalPresentationStyle = UIModalPresentationStyle.fullScreen

Créez une catégorie pour UIViewController (par exemple UIViewController + PresentationStyle). Ajoutez-y le code suivant.

 -(UIModalPresentationStyle)modalPresentationStyle{
     return UIModalPresentationStyleFullScreen;
}

une autre approche consiste à avoir votre propre composant de base viewcontroller dans votre application, et à simplement implémenter les initialiseurs désignés et requis avec une configuration de base, quelque chose comme ceci:

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
    }
}

REMARQUE : si votre contrôleur de vue est contenu dans un contrôleur de navigation qui est en fait présenté de façon modale, le contrôleur de navigation doit alors aborder le problème de la même manière (ce qui signifie que le composant de votre contrôleur de navigation personnalisé est personnalisé de la même manière).

Testé sur Xcode 11.1 sur iOS 13.1 et iOS 12.4

J'espère que cela aide

J'ai eu ce problème avec une vidéo ne présentant plus le plein écran. Ajout de cette ligne, qui a sauvé la journée :-)

videoController.modalPresentationStyle = UIModalPresentationFullScreen;

La solution la plus simple qui a fonctionné pour moi.

viewController.modalPresentationStyle = .fullScreen

Si vous utilisez un UINavigationController et intégrez un ViewController en tant que contrôleur de vue racine, vous vous poserez également le même problème. Utilisez le code suivant pour surmonter.

let vc = UIViewController()
let navController = UINavigationController(rootViewController: vc)
navController.modalPresentationStyle = .fullScreen

class MyViewController: UIViewController {

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

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

Plutôt que d'appeler self.modalPresentationStyle = .fullScreenpour chaque contrôleur de vue, vous pouvez sous-classer UIViewController et simplement l'utiliser MyViewControllerpartout.

Les réponses et suggestions ci-dessus sont exactes, voici une autre version et une manière efficace d'utiliser par programmation.

# 1 a créé une extension UIView

# 2 a créé une méthode ()

//#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)

  }
}

Appel comme ci-dessous

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

OU

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