ios - rotacion - mi ipad no gira la pantalla

cómo bloquear la orientación vertical solo para vista principal usando veloz

Question

He creado una aplicación para iPhone, usando swift , que se compone de muchas vistas integradas en un controlador de navegación. Me gustaría bloquear la vista principal en orientación vertical y solo una subvista de un controlador de navegación bloqueado en orientación horizontal. Aquí hay un ejemplo de lo que quiero decir:

• UINavigationController
  • UiViewController1 (Bloqueado en el retrato) Controlador de vista inicial con un botón colocado en la barra de navegación que le da al usuario la posibilidad de acceder a una lista donde se pueden seleccionar otras vistas
  • UIViewController2 (bloqueado en el paisaje)
  • UiViewController3 (retrato y paisaje)
  • UiViewController4 (retrato y paisaje)
  • ...
  • ...

¿Cómo puedo hacer eso?

Answer 1

Actualización: si tiene problemas para configurar la orientación justo después de que la aplicación se ObjC en iOS 10 , intente hacerlo en ObjC en lugar de Swift , y con la class MyNavigationController: MyNavigationControllerBase :

@implementation ABNavigationControllerBase
- (NSUInteger)supportedInterfaceOrientations
{
return UIInterfaceOrientationMaskPortrait;
}
@end

Swift 3:

class MyNavigationController: UINavigationController {
override func viewDidLoad() {
super.viewDidLoad()
UIDevice.current.setValue(UIInterfaceOrientation.portrait.rawValue, forKey: "orientation")
}
override var shouldAutorotate: Bool {
return false
}
override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
return .portrait
}
override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
return .portrait
}
}

Answer 2

Aquí está la actualización de Swift: -

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
return UIInterfaceOrientationMask.Portrait
}

Answer 3

Editado para swift2.0:

override func shouldAutorotate() -> Bool {
return false
}
override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
return [.Portrait, .PortraitUpsideDown]
}

Answer 4

En el controlador principal donde quieres retrato,

- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
self.orientation = UIInterfaceOrientationMaskPortrait;
//Or self.orientation = UIInterfaceOrientationPortraitUpsideDown
}

y en subVC donde quiere usar Landscape

 self.orientation = UIInterfaceOrientationLandscapeLeft:
self.orientation = UIInterfaceOrientationLandscapeRight:

o puede anular este método

- (NSUInteger)supportedInterfaceOrientations
{
return UIInterfaceOrientationMaskPortrait;
}

Así es como lo haría con Obj-c en iOS7, creo que este código también funcionaría en iOS8

Answer 5

En iOS8, si desea bloquear algún ViewController específico, cree una extensión de UINavigationController (en caso de que lo use):

extension UINavigationController {
public override func shouldAutorotate() -> Bool {
if visibleViewController is YourViewController {
return false
}
return true
}}

Answer 6

Esta es la sintaxis de Swift 3 (XCode 8.2 beta), donde estos métodos se convirtieron en propiedades:

extension UINavigationController {
override open var shouldAutorotate: Bool {
return false
}
}
class ViewController: UIViewController {
/*
...
*/
override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
return UIInterfaceOrientationMask.portrait
}
}

Answer 7

La misma respuesta de JasonJasonJason en Swift 4 (Funcionó correctamente con iOS 11 )

1- La anulación debeAutorizar y orientar las Orientaciones de la interfaz como se muestra a continuación.

extension UINavigationController {
open override var shouldAutorotate: Bool {
return true;
}
open override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
return (visibleViewController?.supportedInterfaceOrientations)!;
}}

2- Y su control de vista principal (retrato en todo momento), debe tener:

 public override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
return UIInterfaceOrientationMask.portrait;
}

3- Luego, en sus controladores de subvista que desea admitir retrato o paisaje:

 public override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
return UIInterfaceOrientationMask.all;
}

Answer 8

Lo importante es describir las orientaciones de interfaz compatibles para toda la aplicación en AppDelegate. Por ejemplo, para bloquear todas las vistas a retrato solo haz esto:

 func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask{
return UIInterfaceOrientationMask.portrait
}

Mucha gente está buscando solo esta respuesta al buscar en Google esta pregunta, así que espero que me disculpen.

Funciona en Swift 3.0

Answer 9

Si su vista está incrustada en el controlador de navegación en el guión gráfico, establezca que el controlador de navegación delegue UINavigationControllerDelegate y agregue el siguiente método

class ViewController: UIViewController, UINavigationControllerDelegate {
func navigationControllerSupportedInterfaceOrientations(navigationController: UINavigationController) -> UIInterfaceOrientationMask {
return UIInterfaceOrientationMask.Portrait
}
}

Answer 10

También respondió [here]

Las cosas pueden ser bastante complicadas cuando tienes una jerarquía de vistas complicada, como tener múltiples controladores de navegación y / o controles de vista de pestañas.

Esta implementación lo coloca en los controladores de vistas individuales para establecer cuándo les gustaría bloquear las orientaciones, en lugar de confiar en el delegado de la aplicación para encontrarlos iterando a través de subvistas o confiando en la herencia.

Swift 3

En AppDelegate:

/// set orientations you want to be allowed in this property by default
var orientationLock = UIInterfaceOrientationMask.all
func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
return self.orientationLock
}

En alguna otra clase struct o helper global, aquí creé AppUtility:

struct AppUtility {
static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {
if let delegate = UIApplication.shared.delegate as? AppDelegate {
delegate.orientationLock = orientation
}
}
/// OPTIONAL Added method to adjust lock and rotate to the desired orientation
static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {
self.lockOrientation(orientation)
UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
}
}

Luego, en el ViewController deseado, desea bloquear las orientaciones:

 override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
AppUtility.lockOrientation(.portrait)
// Or to rotate and lock
// AppUtility.lockOrientation(.portrait, andRotateTo: .portrait)
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
// Don''t forget to reset when view is being removed
AppUtility.lockOrientation(.all)
}

Answer 11

Tienes que aplicar esto a tu controlador de vista superior. Sin embargo, puede hacerlo de una manera limpia y fácil al crear una subclasificación de su controlador de vista superior y establecer una variable dentro de él que haga referencia a cada vez que realice una llamada a:

shouldAutoRotate()

que se llama cuando el dispositivo detecta un cambio de orientación y precede a la llamada a:

supportedInterfaceOrientations()//this is only called if shouldAutoRotate() returns true

Por ejemplo, digamos que mi controlador de vista superior es un Controlador de TabBar:

class SomeSubclassTabBarViewController: UITabBarController { //This subclass allows us to pass along data to each of the tabBars
var dataArray = StoredValues()//also useful for passing info between tabs
var shouldRotate: Bool = false
override func shouldAutorotate() -> Bool { //allow the subviews accessing the tabBarController to set whether they should rotate or not
return self.shouldRotate
}

}

Luego, dentro de la vista que debería tener la capacidad de rotar la pantalla, configure viewAtlarAparece () y viewWillDisappear () así:

override func viewWillAppear(animated: Bool) { //set the rotate capability to true
let sharedTabBarController = self.tabBarController as SomeSubclassTabBarViewController
sharedTabBarController.shouldRotate = true
}
override func viewWillDisappear(animated: Bool) {
let sharedTabBarController = self.tabBarController as SomeSubclassTabBarViewController
sharedTabBarController.shouldRotate = false
}

y solo en caso de que su aplicación falle mientras está en esta pantalla, probablemente sea una buena idea establecer explícitamente el valor de shouldRotate: Bool en cada una de sus vistas dentro del método viewWillLoad ().

Answer 12

De acuerdo con Swift Apple Docs para supportedInterfaceOrientations :

Discusión

Cuando el usuario cambia la orientación del dispositivo, el sistema llama a este método en el controlador de vista raíz o al controlador de vista presentado más arriba que llena la ventana. Si el controlador de vista admite la nueva orientación, la ventana y el controlador de vista se rotan a la nueva orientación. Este método solo se invoca si el método shouldAutorotate del controlador de vista devuelve verdadero.

Su controlador de navegación debe anular shouldAutorotate y supportedInterfaceOrientations como se muestra a continuación. Hice esto en una extensión UINavigationController para facilitar:

extension UINavigationController {
public override func shouldAutorotate() -> Bool {
return true
}
public override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
return (visibleViewController?.supportedInterfaceOrientations())!
}
}

Y su control de vista principal (retrato en todo momento), debe tener:

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
return UIInterfaceOrientationMask.Portrait
}

Luego, en sus controladores de subvista que desea admitir retrato o paisaje:

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
return UIInterfaceOrientationMask.All
}

Editar: actualizado para iOS 9 :-)