Präsentation von Modal im iOS 13-Vollbildmodus

In iOS 13 gibt es ein neues Verhalten für den Modal View Controller, wenn er angezeigt wird.

Jetzt ist es standardmäßig nicht mehr Vollbild und wenn ich versuche, nach unten zu rutschen, schließt die App den View Controller einfach automatisch.

Wie kann ich dieses Verhalten verhindern und zum alten modalen Vollbild-VC zurückkehren?

Vielen Dank

Mit iOS 13 hat Apple , wie im Platforms State of the Union während der WWDC 2019 angegeben, eine neue Standardkartenpräsentation eingeführt. Um den Vollbildmodus zu erzwingen, müssen Sie ihn explizit angeben mit:

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

Ich füge eine Information hinzu, die für jemanden nützlich sein könnte. Wenn Sie einen Storyboard-Übergang haben, müssen Sie die Eigenschaft kind auf Modally Present und die Presentation- Eigenschaft auf Full Screen setzen, um zum alten Stil zurückzukehren .

Ich hatte dieses Problem in der ersten Ansicht direkt nach dem Startbildschirm. Die Lösung für mich, da ich keinen Abschnitt oder keine Logik definiert hatte, bestand darin, die Präsentation wie hier gezeigt von automatisch auf Vollbild umzustellen:

Es gibt mehrere Möglichkeiten, dies zu tun, und ich denke, jede könnte für ein Projekt passen, aber nicht für ein anderes. Deshalb dachte ich, ich werde sie hier behalten, vielleicht läuft jemand anderes zu einem anderen Fall.

1- Vorhanden überschreiben

Wenn Sie eine haben BaseViewController, können Sie die present(_ viewControllerToPresent: animated flag: completion:)Methode überschreiben .

class BaseViewController: UIViewController {

  // ....

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

  // ....
}

Auf diese Weise müssen Sie bei keinem presentAufruf Änderungen vornehmen, da wir die presentMethode einfach überschrieben haben .

2- Eine Erweiterung:

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

Verwendungszweck:

presentInFullScreen(viewController, animated: true)

3- Für einen UIViewController

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

4- Vom Storyboard

Wählen Sie einen Abschnitt aus und stellen Sie die Präsentation auf ein 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)
   }
}

Verwendung: Fügen Sie
in Ihrem AppDelegateInneren application(_ application: didFinishLaunchingWithOptions)diese Zeile hinzu:

UIViewController.swizzlePresent()

Auf diese Weise müssen Sie bei keinem aktuellen Aufruf Änderungen vornehmen, da wir die aktuelle Methodenimplementierung zur Laufzeit ersetzen.
Wenn Sie wissen müssen, was schwirrt, können Sie diesen Link überprüfen: https://nshipster.com/swift-objc-runtime/

Ich habe Swizzling für iOS 13 verwendet

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

dann setzen Sie dies

UIViewController.preventPageSheetPresentation

irgendwo

Zum Beispiel in AppDelegate

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

    UIViewController.preventPageSheetPresentation
    // ...
    return true
}

Für Objective-C-Benutzer

Verwenden Sie einfach diesen Code

 [vc setModalPresentationStyle: UIModalPresentationFullScreen];

Oder wenn Sie es speziell in iOS 13.0 hinzufügen möchten, verwenden Sie

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

Einzeiler:

modalPresentationStylemuss auf dem Navigationscontroller eingestellt werden, der angezeigt wird .

iOS 13 und niedriger iOS-Version Vollbild mit overCurrentContextund navigationController

Getesteter Code

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

modalPresentationStyle muss bei navigationController festgelegt werden .

Als Hinweis: Wenn Sie Präsens an a ViewControllersenden, das in a eingebettet ist NavigationController, müssen Sie das NavigationControllerauf .fullScreenund nicht das VC setzen.

Sie können dies wie @davidbates oder programmgesteuert (wie @pascalbros) tun.

Ein Beispielszenario:

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

Ich musste beides tun:

1. Legen Sie den Präsentationsstil als Vollbild fest

   

2. Legen Sie die obere Leiste als durchscheinende Navigationsleiste fest

modalPresentationStyleVor dem Präsentieren ändern

vc.modalPresentationStyle = UIModalPresentationFullScreen;

Hier ist eine einfache Lösung, ohne eine einzelne Zeile zu codieren.

• Wählen Sie View Controller im Storyboard
• Wählen Sie das Attribut Inspector
• Stellen Sie die Präsentation "Automatisch" auf "Vollbild" ein (siehe Abbildung unten)

Durch diese Änderung wird das Verhalten der iPad-App wie erwartet ausgeführt, andernfalls wird der neue Bildschirm in der Mitte des Bildschirms als Popup angezeigt.

Wenn Sie einen UITabController mit Bildschirmen mit eingebetteten Navigationscontrollern haben, müssen Sie die UITabController- Präsentation auf Vollbild einstellen, wie in der Abbildung unten gezeigt

Hier ist die Lösung für Objective-C

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

vc.modalPresentationStyle = UIModalPresentationFullScreen;

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

Neueste für iOS 13 und Swift 5.x.

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

vc.modalPresentationStyle = .fullScreen

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

Hier ist meine Version von Fix in ObjectiveC unter Verwendung von Kategorien. Bei diesem Ansatz haben Sie das Standardverhalten von UIModalPresentationStyleFullScreen, bis ein anderes explizit festgelegt wird.

#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

Alle anderen Antworten sind ausreichend, aber für ein großes Projekt wie das unsere und für Navigationen sowohl im Code als auch im Storyboard ist dies eine ziemlich entmutigende Aufgabe.

Für diejenigen, die Storyboard aktiv nutzen. Dies ist mein Rat: Verwenden Sie Regex.

Das folgende Format eignet sich nicht für Vollbildseiten:

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

Das folgende Format eignet sich für Vollbildseiten:

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

Der folgende mit VS CODE kompatible reguläre Ausdruck konvertiert alle Seiten im alten Stil in Seiten im neuen Stil. Möglicherweise müssen Sie Sonderzeichen vermeiden, wenn Sie andere Regex-Engines / Texteditoren verwenden.

Suche Regex

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

Regex ersetzen

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

Anfangs ist der Standardwert fullscreenfür modalPresentationStyle, in iOS 13 werden jedoch Änderungen an der vorgenommenUIModalPresentationStyle.automatic .

Wenn Sie die Vollbild-View - Controller machen wollen , müssen Sie das ändern modalPresentationStylezufullScreen .

Weitere Informationen finden Sie in der UIModalPresentationStyle Apple-Dokumentation und in den Richtlinien für die Benutzeroberfläche von Apple, wo welche Modalität verwendet werden soll.

Sie können dies ganz einfach tun. Öffnen Sie Ihr Storyboard als Quellcode und suchen Sie kind="presentation"in allen Seague-Tags mit kind = Präsentation ein zusätzliches AttributmodalPresentationStyle="fullScreen"

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

// Wenn Sie das Wischen deaktivieren möchten, um es zu schließen, fügen Sie eine Zeile hinzu

Obj.isModalInPresentation = true

Weitere Informationen finden Sie im Apple-Dokument .

Ich habe es mit der Methode Swizzling (Swift 4.2) erreicht:

So erstellen Sie eine UIViewController-Erweiterung wie folgt

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

und in AppDelegate in der Anwendung: didFinishLaunchingWithOptions: Rufen Sie den Swizzling-Code auf, indem Sie Folgendes aufrufen:

UIViewController.setPresentationStyle_fullScreen()

Das hat bei mir funktioniert:

yourViewController.modalPresentationStyle = UIModalPresentationStyle.fullScreen

Erstellen Sie eine Kategorie für UIViewController (z. B. UIViewController + PresentationStyle). Fügen Sie den folgenden Code hinzu.

 -(UIModalPresentationStyle)modalPresentationStyle{
     return UIModalPresentationStyleFullScreen;
}

Ein alternativer Ansatz besteht darin, eine eigene Basis-Viewcontroller-Komponente in Ihrer App zu haben und nur die festgelegten und erforderlichen Initialisierer mit einem grundlegenden Setup zu implementieren, etwa wie folgt:

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

HINWEIS : Wenn Ihr Ansichtscontroller in einem Navigationscontroller enthalten ist, der tatsächlich modal dargestellt wird, sollte der Navigationscontroller das Problem auf dieselbe Weise angehen (dh Ihre benutzerdefinierte Navigationscontrollerkomponente muss auf dieselbe Weise angepasst werden

Getestet auf Xcode 11.1 unter iOS 13.1 und iOS 12.4

Ich hoffe es hilft

Ich hatte dieses Problem mit einem Video, das nicht mehr im Vollbildmodus angezeigt wird. Fügte diese Zeile hinzu, die den Tag rettete :-)

videoController.modalPresentationStyle = UIModalPresentationFullScreen;

Die einfachste Lösung, die für mich funktioniert hat.

viewController.modalPresentationStyle = .fullScreen

Wenn Sie einen UINavigationController verwenden und einen ViewController als Root-View-Controller einbetten, treten ebenfalls dieselben Probleme auf. Verwenden Sie folgenden Code, um zu überwinden.

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

Anstatt self.modalPresentationStyle = .fullScreenjeden View Controller aufzurufen, können Sie UIViewController in Unterklassen unterteilen und einfach MyViewControllerüberall verwenden.

Die obigen Antworten und Vorschläge sind richtig, unten ist eine andere Version und eine effiziente programmgesteuerte Verwendung.

# 1 Erstellt eine UIView-Erweiterung

# 2 Erstellt eine Methode ()

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

  }
}

Aufruf wie unten

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

ODER

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