Prezentacja modalu w iOS 13 na pełnym ekranie

W iOS 13 pojawiło się nowe zachowanie dla kontrolera widoku modalnego podczas prezentacji.

Teraz domyślnie nie jest pełnoekranowy, a kiedy próbuję zjechać w dół, aplikacja po prostu automatycznie wyłącza kontroler widoku.

Jak mogę temu zapobiec i wrócić do starego pełnoekranowego modalnego vc?

Dzięki

Z iOS 13, jak stwierdzono w Platforms State of the Union podczas WWDC 2019, Apple wprowadził nową domyślną prezentację kart. Aby wymusić pełny ekran, musisz to wyraźnie określić za pomocą:

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

Dodaję informacje, które mogą być przydatne dla kogoś. Jeśli masz jakiś segment scenorysu, aby powrócić do starego stylu, musisz ustawić właściwość kind na Present Modally, a właściwość Presentation na pełny ekran .

Miałem ten problem w początkowym widoku zaraz po ekranie uruchamiania. Rozwiązaniem dla mnie, ponieważ nie miałem zdefiniowanego segmentu ani logiki, było przełączenie prezentacji z automatycznej na pełnoekranową, jak pokazano tutaj:

Można to zrobić na wiele sposobów i myślę, że każdy może pasować do jednego projektu, ale nie do innego, więc pomyślałem, że zatrzymam je tutaj, może ktoś inny wybiegnie w inną sprawę.

1- Zastąp obecny

Jeśli masz BaseViewController, możesz zastąpić present(_ viewControllerToPresent: animated flag: completion:)metodę.

class BaseViewController: UIViewController {

  // ....

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

  // ....
}

W ten sposób nie musisz wprowadzać żadnych zmian w żadnym presentwywołaniu, ponieważ po prostu przesłoniliśmy presentmetodę.

2- Rozszerzenie:

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

Stosowanie:

presentInFullScreen(viewController, animated: true)

3- Dla jednego UIViewController

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

4- Z Storyboard

Wybierz segue i ustaw prezentację na 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)
   }
}

Zastosowanie:
W swoim AppDelegatewnętrzu application(_ application: didFinishLaunchingWithOptions)dodaj ten wiersz:

UIViewController.swizzlePresent()

W ten sposób nie musisz wprowadzać żadnych zmian w żadnym bieżącym wywołaniu, ponieważ zastępujemy obecną implementację metody w środowisku wykonawczym.
Jeśli chcesz wiedzieć, co jest zawrotne, możesz sprawdzić ten link: https://nshipster.com/swift-objc-runtime/

Użyłem swizzlinga dla 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)
    }
}

następnie połóż to

UIViewController.preventPageSheetPresentation

gdzieś

na przykład w AppDelegate

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

    UIViewController.preventPageSheetPresentation
    // ...
    return true
}

Dla użytkowników celu C

Po prostu użyj tego kodu

 [vc setModalPresentationStyle: UIModalPresentationFullScreen];

Lub jeśli chcesz dodać go konkretnie w iOS 13.0, użyj

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

Jedna wkładka:

modalPresentationStylenależy ustawić w nawigatorze, który jest prezentowany .

iOS 13 i niższa wersja iOS fullScreen z overCurrentContexti navigationController

Testowany kod

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

modalPresentationStyle wymagają ustawienia w navigationController .

Jako wskazówka: Jeśli zadzwonisz na obecny, ViewControllerktóry jest osadzony w środku NavigationController, musisz ustawić NavigationControllerna.fullScreen i nie VC.

Możesz to zrobić jak @davidbates lub zrobić to programowo (jak @pascalbros).

Przykładowy scenariusz:

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

Musiałem zrobić oba:

1. Ustaw styl prezentacji na Pełny ekran

   

2. Ustaw górny pasek jako półprzezroczysty pasek nawigacyjny

Zmień modalPresentationStyleprzed przedstawieniem

vc.modalPresentationStyle = UIModalPresentationFullScreen;

Oto proste rozwiązanie bez kodowania jednej linii.

• Wybierz opcję Wyświetl kontroler w serii ujęć
• Wybierz atrybut Inspector
• Ustaw prezentację „Automatycznie” na „Pełny ekran”, jak pokazano poniżej

Ta zmiana powoduje, że zachowanie aplikacji na iPada jest zgodne z oczekiwaniami, w przeciwnym razie nowy ekran będzie wyświetlany na środku ekranu jako wyskakujące okienko.

Jeśli masz UITabController z ekranami z wbudowanymi kontrolerami nawigacji, musisz ustawić Prezentację UITabController na FullScreen, jak pokazano na poniższym obrazku

Oto rozwiązanie dla Objective-C

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

vc.modalPresentationStyle = UIModalPresentationFullScreen;

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

Najnowsze na iOS 13 i Swift 5.x

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

vc.modalPresentationStyle = .fullScreen

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

Oto moja wersja poprawki w ObjectiveC przy użyciu kategorii. Dzięki takiemu podejściu będziesz mieć domyślne zachowanie UIModalPresentationStyleFullScreen, dopóki inne nie zostanie wyraźnie ustawione.

#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

Wszystkie pozostałe odpowiedzi są wystarczające, ale w przypadku dużego projektu, takiego jak nasz i gdzie nawigacja odbywa się zarówno w kodzie, jak i scenorysie, jest to dość trudne zadanie.

Dla tych, którzy aktywnie korzystają z Storyboard. Oto moja rada: skorzystaj z Regex.

Poniższy format nie jest odpowiedni dla stron pełnoekranowych:

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

Poniższy format jest odpowiedni dla stron pełnoekranowych:

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

Poniższe wyrażenie regularne zgodne z VS CODE przekonwertuje wszystkie strony w starym stylu na strony w nowym stylu. Może być konieczne uniknięcie specjalnych znaków, jeśli używasz innych silników wyrażeń regularnych / edytorów tekstu.

Wyszukaj Regex

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

Wymień Regex

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

Początkowo wartością domyślną jest fullscreenmodalPresentationStyle, ale w iOS 13 jego zmiany dotyczą UIModalPresentationStyle.automatic.

Jeśli chcesz zrobić kontroler widoku pełnoekranowego, musisz zmienić modalPresentationStylenafullScreen .

Zapoznaj się z UIModalPresentationStyle dokumentacją firmy Apple, aby uzyskać więcej szczegółów, i zapoznaj się z wytycznymi dotyczącymi interfejsu Apple Apple, gdzie należy użyć jakiej modalności.

Możesz to łatwo otworzyć Otwórz scenorys jako kod źródłowy i wyszukaj kind="presentation"we wszystkich tagach seague z kind = prezentacja dodaj dodatkowy atrybutmodalPresentationStyle="fullScreen"

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

// jeśli chcesz wyłączyć przesunięcie, aby je odrzucić, dodaj linię

Obj.isModalInPresentation = true

Sprawdź dokument Apple, aby uzyskać więcej informacji.

Osiągnąłem to, używając metody swizzling (Swift 4.2):

Aby utworzyć rozszerzenie UIViewController w następujący sposób

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

oraz w AppDelegate, w aplikacji: didFinishLaunchingWithOptions: wywołaj swizzling kod, wywołując:

UIViewController.setPresentationStyle_fullScreen()

To działało dla mnie:

yourViewController.modalPresentationStyle = UIModalPresentationStyle.fullScreen

Utwórz kategorię dla UIViewController (powiedz UIViewController + PresentationStyle). Dodaj do niego następujący kod.

 -(UIModalPresentationStyle)modalPresentationStyle{
     return UIModalPresentationStyleFullScreen;
}

alternatywnym podejściem jest posiadanie własnego komponentu podstawowego kontrolera widoku w aplikacji i po prostu implementacja wyznaczonych i wymaganych inicjatorów z podstawową konfiguracją, coś takiego:

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

UWAGA : Jeśli twój kontroler widoku jest zawarty w kontrolerze nawigacyjnym, który jest faktycznie prezentowany modalnie, to kontroler nawigacyjny powinien podejść do problemu w ten sam sposób (co oznacza, że ​​dostosujesz niestandardowy komponent kontrolera nawigacji w ten sam sposób

Testowane na Xcode 11.1 na iOS 13.1 i iOS 12.4

Mam nadzieję, że to pomoże

Miałem ten problem z filmem, który nie wyświetla już pełnego ekranu. Dodano tę linię, która uratowała dzień :-)

videoController.modalPresentationStyle = UIModalPresentationFullScreen;

Najprostsze rozwiązanie, które działało dla mnie.

viewController.modalPresentationStyle = .fullScreen

Jeśli korzystasz z UINavigationController i osadzasz ViewController jako główny kontroler widoku, to i ty miałbyś problem z tym samym problemem. Aby pokonać, użyj następującego kodu.

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

Zamiast wywoływać self.modalPresentationStyle = .fullScreendla każdego kontrolera widoku, możesz podklasować UIViewController i używać go MyViewControllerwszędzie.

Powyższe odpowiedzi i sugestie są słuszne, poniżej jest kolejna wersja i skuteczny sposób korzystania programowo.

# 1 Utworzono rozszerzenie UIView

# 2 Utworzono metodę ()

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

  }
}

Wywoływanie jak poniżej

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

LUB

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