Presentazione modale in iOS 13 a schermo intero

In iOS 13 c'è un nuovo comportamento per il controller di visualizzazione modale quando viene presentato.

Ora non è a schermo intero per impostazione predefinita e quando provo a scorrere verso il basso, l'app elimina automaticamente View Controller.

Come posso prevenire questo comportamento e tornare al vecchio vc modale a schermo intero?

Grazie

Con iOS 13, come affermato nello stato dell'Unione delle piattaforme durante il WWDC 2019, Apple ha introdotto una nuova presentazione di carte predefinita. Per forzare lo schermo intero devi specificarlo esplicitamente con:

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

Aggiungo un'informazione che potrebbe essere utile per qualcuno. Se segui uno storyboard, per tornare al vecchio stile, devi impostare la proprietà kind su Present Modally e la proprietà Presentation su Full Screen .

Ho avuto questo problema nella vista iniziale subito dopo la schermata di avvio. La soluzione per me, dato che non avevo un seguito o una logica definita, era di cambiare la presentazione da automatica a schermo intero, come mostrato qui:

Esistono diversi modi per farlo, e penso che ognuno potrebbe adattarsi a un progetto ma non a un altro, quindi ho pensato di tenerli qui, forse qualcun altro si imbatterà in un caso diverso.

1- Sostituisci presente

Se ne hai uno BaseViewControllerpuoi sovrascrivere il present(_ viewControllerToPresent: animated flag: completion:)metodo.

class BaseViewController: UIViewController {

  // ....

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

  // ....
}

In questo modo non è necessario apportare alcuna modifica a nessuna presentchiamata, poiché abbiamo appena annullato il presentmetodo.

2- Un'estensione:

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

Uso:

presentInFullScreen(viewController, animated: true)

3- Per un UIViewController

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

4- Dallo storyboard

Seleziona un seguito e imposta la presentazione su 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)
   }
}

Uso:
Nel tuo AppDelegateinterno application(_ application: didFinishLaunchingWithOptions)aggiungi questa riga:

UIViewController.swizzlePresent()

In questo modo non è necessario apportare alcuna modifica a nessuna chiamata presente, poiché stiamo sostituendo l'implementazione del metodo attuale in fase di esecuzione.
Se hai bisogno di sapere cosa gira, puoi controllare questo link: https://nshipster.com/swift-objc-runtime/

Ho usato swizzling per 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)
    }
}

quindi metti questo

UIViewController.preventPageSheetPresentation

da qualche parte

ad esempio in AppDelegate

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

    UIViewController.preventPageSheetPresentation
    // ...
    return true
}

Per gli utenti di Objective-C

Usa questo codice

 [vc setModalPresentationStyle: UIModalPresentationFullScreen];

Oppure, se si desidera aggiungerlo in particolare in iOS 13.0, utilizzare

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

Una fodera:

modalPresentationStyledeve essere impostato sul controller di navigazione che viene presentato .

iOS 13 e versioni precedenti iOS versione a schermo intero con overCurrentContexte navigationController

Codice testato

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

modalPresentationStyle deve essere impostato su navigationController .

Come suggerimento: se chiamate presente a un ViewControllerche è incorporato all'interno di un, NavigationControllerdovete impostare NavigationControllersu .fullScreene non sul VC.

Puoi farlo come @davidbates o farlo in modo programmatico (come @pascalbros).

Uno scenario di esempio:

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

Ho dovuto fare entrambe le cose:

1. Imposta lo stile di presentazione come Schermo intero

   

2. Imposta la barra superiore come barra di navigazione traslucida

Cambia modalPresentationStyleprima di presentare

vc.modalPresentationStyle = UIModalPresentationFullScreen;

Ecco una soluzione semplice senza codificare una sola riga.

• Seleziona Visualizza controller nello Storyboard
• Seleziona l'attributo Inspector
• Impostare la presentazione "Automatico" su "Schermo intero" come da immagine sotto

Questa modifica rende il comportamento dell'app per iPad come previsto, altrimenti il ​​nuovo schermo viene visualizzato al centro dello schermo come popup.

Se si dispone di un UITabController con schermate con controller di navigazione incorporati, è necessario impostare la presentazione di UITabController su FullScreen come mostrato nell'immagine seguente

Ecco la soluzione per Objective-C

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

vc.modalPresentationStyle = UIModalPresentationFullScreen;

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

Più recente per iOS 13 e Swift 5.x

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

vc.modalPresentationStyle = .fullScreen

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

Ecco la mia versione della correzione in ObjectiveC usando Categorie. Con questo approccio avrai il comportamento UIModalPresentationStyleFullScreen predefinito fino a quando un altro non viene impostato esplicitamente.

#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

Tutte le altre risposte sono sufficienti, ma per un grande progetto come il nostro e in cui si effettuano navigazioni sia in codice che in storyboard, è un compito piuttosto scoraggiante.

Per coloro che stanno attivamente utilizzando Storyboard. Questo è il mio consiglio: usa Regex.

Il seguente formato non è adatto per le pagine a schermo intero:

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

Il seguente formato è buono per le pagine a schermo intero:

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

Il seguente regex compatibile con VS CODE convertirà tutte le pagine di vecchio stile in nuove pagine di stile. Potrebbe essere necessario evitare caratteri speciali se si utilizzano altri motori regex / editor di testo.

Cerca Regex

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

Sostituisci Regex

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

Inizialmente, il valore predefinito è fullscreenper modalPresentationStyle, ma in iOS 13 le sue modifiche a UIModalPresentationStyle.automatic.

Se si vuole fare la vista del regolatore a schermo intero è necessario cambiare l' modalPresentationStylea fullScreen.

Fare riferimento alla UIModalPresentationStyle documentazione di Apple per maggiori dettagli e consultare le linee guida dell'interfaccia umana di Apple per sapere dove utilizzare quale modalità.

Puoi farlo facilmente Apri lo storyboard come codice sorgente e cerca kind="presentation", in tutto il tag seague con kind = presentation aggiungi un attributo extramodalPresentationStyle="fullScreen"

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

// se si desidera disabilitare lo scorrimento per ignorarlo, aggiungere la riga

Obj.isModalInPresentation = true

Controlla il documento Apple per ulteriori informazioni.

L'ho raggiunto usando il metodo swizzling (Swift 4.2):

Per creare un'estensione UIViewController come segue

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

e in AppDelegate, nell'applicazione: didFinishLaunchingWithOptions: invoca il codice di scorrimento chiamando:

UIViewController.setPresentationStyle_fullScreen()

Questo ha funzionato per me:

yourViewController.modalPresentationStyle = UIModalPresentationStyle.fullScreen

Crea una categoria per UIViewController (ad esempio UIViewController + PresentationStyle). Aggiungi il seguente codice ad esso.

 -(UIModalPresentationStyle)modalPresentationStyle{
     return UIModalPresentationStyleFullScreen;
}

un approccio alternativo consiste nell'avere il proprio componente viewcontroller di base nella propria app e implementare semplicemente gli inizializzatori designati e richiesti con un'impostazione di base, simile al seguente:

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

NOTA : se il controller di visualizzazione è contenuto in un controller di navigazione che viene effettivamente presentato in modo modale, il controller di navigazione dovrebbe affrontare il problema allo stesso modo (ovvero, avere il componente del controller di navigazione personalizzato personalizzato nello stesso modo

Testato su Xcode 11.1 su iOS 13.1 e iOS 12.4

Spero che sia d'aiuto

Ho avuto questo problema con un video che non presentava più a schermo intero. Aggiunta questa riga, che ha salvato la giornata :-)

videoController.modalPresentationStyle = UIModalPresentationFullScreen;

La soluzione più semplice che ha funzionato per me.

viewController.modalPresentationStyle = .fullScreen

Se si utilizza un UINavigationController e si incorpora un ViewController come controller di visualizzazione radice, si verificherebbe anche lo stesso problema. Utilizzare il seguente codice per superare.

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

Piuttosto che chiamare self.modalPresentationStyle = .fullScreenper ogni controller di visualizzazione, è possibile sottoclassare UIViewController e utilizzarlo MyViewControllerovunque.

Le risposte e i suggerimenti sopra riportati sono giusti, di seguito è riportata un'altra versione e un modo efficace di utilizzare a livello di codice.

# 1 ha creato un'estensione UIView

# 2 ha creato un metodo ()

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

  }
}

Invocando come di seguito

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

O

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