Comment vérifier dans quelle position (paysage ou portrait) est l'iPhone maintenant?

J'ai une application avec une barre d'onglet, et de la valeur liquidative des contrôleurs dans chaque onglet. Lorsque l'utilisateur secoue l'appareil, un UIImageView apparaît comme un enfant de vue de la valeur liquidative du contrôleur. Mais le UIImageView doit contenir une image en particulier, selon le dispositif actuel de l'orientation.

Si je vous écris juste

- (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)
   if (interfaceOrientation == UIInterfaceOrientationPortrait || interfaceOrientation == UIInterfaceOrientationPortraitUpsideDown) { 
   //Code
   }
   else if (interfaceOrientation == UIInterfaceOrientationLandscapeRight||interfaceOrientation == UIInterfaceOrientationLandscapeLeft) {
   //Code
   }
}

La vue va juste fou si l'utilisateur fait pivoter l'appareil avant de l'agiter.

Est-il une méthode pour obtenir des iPhones orientation actuelle?

InformationsquelleAutor Knodel | 2010-03-25

ios objective-c

33

Utiliser le [[UIDevice currentDevice] orientation] méthode, comme spécifié ici.
- Merci, mais dont les valeurs peuvent l'orientation de l'être? De -90 til 90 - portrait et de -180 jusqu'à -90 et à partir de 90 til 180-paysage?
- Voir @Shirkrin la réponse de l' - elle renvoie une valeur de type UIDeviceOrientation, qui est un enum d'une certaine liste de valeurs.
- pas fonctionné pour moi que parfois il retourne UIInterfaceOrientetionUnknown
- Ne fonctionnent pas toujours, j'ai enfin vérifier l'orientation par ma largeur de la fenêtre. Si elle est égale 320.0 puis, portrait, d'autre paysage.
- Qui semble fragile – que faire si vous êtes sur un iPad, ou si le prochain iPhone révision élargit l'écran passé de 320 points? Le UIDevice classe vous dit tout ce qu'il peut – si vous obtenez un Inconnu orientation de retour, eh bien, alors il est vraiment inconnu. Vous pouvez choisir une valeur par défaut (par exemple, défaut de portrait dans ce cas), mais vous ne devriez pas faire des hypothèses que la largeur de la fenêtre correspond à une orientation.
- Si vous n'avez pas de soins sur le appareil de l'orientation, mais plutôt que le interface de l'orientation, vous pouvez demander à votre UIViewController pour son -interfaceOrientation à la place. Qui n'a pas de valeur Inconnue, de sorte que vous aurez toujours quelque chose de bien défini par l'arrière, plutôt que d'avoir à en déduire une orientation.
- Merci @Tim, je sais que c'est pas fiable et ne fonctionne pas sur iPad. Mais c'est juste une solution momentanée bien que je trouve quelque chose de mieux. Je vais essayer de vous deuxième réponse ;)!
- Merci beaucoup @Tim, -(UIInterfaceOrientation)interfaceOrientation méthode déclarée sur UIViewController fonctionne très bien.
- Elle ne vous dit pas si c'est landscape ou portrait cela vous en dit plus: landscape, portrait ou flat
InformationsquelleAutor Tim
49

Ici sont des macros UIDeviceOrientationIsLandscape et UIDeviceOrientationIsPortrait

donc plutôt de vérifier séparément, vous pouvez le faire comme ceci ...
```
if (UIDeviceOrientationIsLandscape([UIDevice currentDevice].orientation))
{
    //code for landscape orientation      
}
```
OU
```
 if (UIDeviceOrientationIsPortrait([UIDevice currentDevice].orientation))
 {
     //code for Portrait orientation       
 }
```
- J'ai remarqué que ce n'est pas retourner les valeurs correctes si l'application se lance et n'a pas changé d'orientation encore. Est-il un moyen de contourner cela?
- swift 4/5? et si le téléphone en position horizontale - comment savoir si il est en portrait ou en paysage?
InformationsquelleAutor Azhar
17

Comme beno dit, cela semble une meilleure solution si vous êtes à la détection de l'orientation de début de votre point de Vue. Je ne pouvais pas obtenir approuvé réponse à retourner un résultat au début de mon installation, mais cela fonctionne à merveille.
```
if (UIDeviceOrientationIsPortrait(self.interfaceOrientation)){
//DO Portrait
}else{
//DO Landscape
}
```
- Merci beaucoup!
- Merci, c'est la réponse dont j'avais besoin. Pour plus de précisions, le self dans votre code est une instance de UIViewController.
- Cela peut ne pas fonctionner si l'auto n'est pas en plein écran.
- auto.interfaceOrientation a été abandonné depuis iOS 8.1
InformationsquelleAutor Jim True
11

Addon pour le déjà répondu à la question:

Vous utilisez [[UIDevice currentDevice] orientation] qui donnera une de ces valeurs:
```
typedef enum {
   UIDeviceOrientationUnknown,
   UIDeviceOrientationPortrait,
   UIDeviceOrientationPortraitUpsideDown,
   UIDeviceOrientationLandscapeLeft,
   UIDeviceOrientationLandscapeRight,
   UIDeviceOrientationFaceUp,
   UIDeviceOrientationFaceDown
} UIDeviceOrientation;
```
La documentation peut être trouvée ici - (orientation) et ici - (UIDeviceOrientation).

(Je ne veux pas prétendre à l'ancien réponse, mais cette information était de grande pour un commentaire.)
- Beaucoup plus complète que celle de ma réponse. Merci et +1
InformationsquelleAutor Shirkrin
6

Vous pouvez également utiliser le interfaceOrientation propriété de la classe UIViewController, si vous êtes coincé et en permanence faire UIDeviceOrientationUnknown de UIDevice.

Il y a un bon résumé de pourquoi [[UIDevice currentdevice] orientation] peut parfois échouer ici: http://bynomial.com/blog/?p=25, surtout si vous voulez détecter l'orientation rapidement (par exemple, si vous vouliez vérifier droit lors de l'application qui vient de sortir de l'arrière-plan).
- Je pense que le blog est la meilleure et la plus complète, la réponse à cette question. Merci pour le lien vers elle.
InformationsquelleAutor beno

Il vous aide à...

-(void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation
{
if ([[UIDevice currentDevice] orientation] == UIDeviceOrientationLandscapeLeft || [[UIDevice currentDevice] orientation ]== UIDeviceOrientationLandscapeRight)
 {
   NSLog(@"Lanscapse");
 }
if([[UIDevice currentDevice] orientation] == UIDeviceOrientationPortrait || [[UIDevice currentDevice] orientation] == UIDeviceOrientationPortraitUpsideDown )
 {
   NSLog(@"UIDeviceOrientationPortrait");
 }
}

InformationsquelleAutor Mohamed Nazir

6

Essayez ceci:
```
[[UIApplication sharedApplication] statusBarOrientation]
```
Ou Swift 3:
```
UIApplication.shared.statusBarOrientation
```
Pour contrôler spécifiquement pour une orientation particulière, vous pouvez également essayer les isLandscape ou isPortrait propriété comme suit:
```
UIApplication.shared.statusBarOrientation.isLandscape
```
Le problème avec [[UIDevice currentDevice] orientation] est qu'il est également de retour UIInterfaceOrientationUnknown qui statusBarOrientation ne le fait pas.

Il y a aussi un UIViewController propriété interfaceOrientation mais elle a été frappée dans iOS 8, il n'est donc pas recommandé.

Vous voir la documentation pour les statusBarOrientation ici

InformationsquelleAutor Varun

Vous pouvez également définir des constantes pour gagner du temps :

#define LANDSCAPE UIInterfaceOrientationIsLandscape(self.interfaceOrientation)
#define LANDSCAPE_RIGHT [UIDevice currentDevice].orientation == UIDeviceOrientationLandscapeLeft
#define LANDSCAPE_LEFT [UIDevice currentDevice].orientation == UIDeviceOrientationLandscapeRight
#define PORTRAIT UIInterfaceOrientationIsPortrait(self.interfaceOrientation)
#define PORTRAIT_REVERSE [UIDevice currentDevice].orientation == UIDeviceOrientationPortraitUpsideDown

#définit le PAYSAGE UIDeviceOrientationIsLandscape([UIDevice currentDevice].l'orientation) Pourrait vouloir retravailler pour des méthodes obsolètes.
Devrait être #define IS_LANDSCAPE UIInterfaceOrientationIsLandscape([[UIApplication sharedApplication] statusBarOrientation])

InformationsquelleAutor Beninho85

Aussi Simple Solution de Swift 4.2

override func didRotate(from fromInterfaceOrientation: UIInterfaceOrientation) {
        switch UIDevice.current.orientation{
        case .portrait:
            print("Portrait")
        case .portraitUpsideDown:
            print("PortraitUpsideDown")
        case .landscapeLeft:
            print("LandscapeLeft")
        case .landscapeRight:
            print("LandscapeRight")
        default:
            print("Another")
        }
    }

InformationsquelleAutor Dhaval Gevariya

Vous pourrez le consulter comme (Swift 3):

var isPortrait: Bool {
  let orientation = UIDevice.current.orientation
  switch orientation {
    case .portrait, .portraitUpsideDown:
      return true

    case .faceUp, .faceDown:
      //Check the interface orientation
      let interfaceOrientation = UIApplication.shared.statusBarOrientation
      switch interfaceOrientation{
        case .portrait, .portraitUpsideDown:
          return true
        default:
          return false
      }
   default: //.unknown
     return false //not very satisfying to return false as if we were in landscape :-/
   }
}

Si vous êtes dans un ViewController, vous pouvez aussi faire comme si (c'est ce que j'ai fait):

private var isPortrait: Bool {
    let orientation = UIDevice.current.orientation
    switch orientation {
    case .portrait, .portraitUpsideDown:
        return true
    case .landscapeLeft, .landscapeRight:
        return false
    default: //unknown or faceUp or FaceDown
        return self.view.width < self.view.height
    }
}

Bien que même ce qui devrait être suffisant dans ce cas:

private var isPortrait: Bool {
     return self.view.width < self.view.height
}

InformationsquelleAutor Frédéric Adda

1

Mise à jour de ce à iOS 8+ où la UIViewController.interfaceOrienation est obsolète, vous devez utiliser traitCollections. Ainsi, par exemple, pour vérifier paysage sur l'iPhone, vous pouvez utiliser:
```
if self.traitCollection.verticalSizeClass == .compact
{
  your code
}
```
Avis que ce n'est pas le cas sur l'iPad, parce que sur l'iPad en mode paysage, la taille de la classe n'est pas compact.
Apple Doc Lien

InformationsquelleAutor MNassar

Obtenir l'orientation actuelle

- (void)viewDidLoad
{
    [super viewDidLoad];

//Do any additional setup after loading the view, typically from a nib.

    UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];

    if (orientation == UIInterfaceOrientationLandscapeLeft) {
        NSLog(@"Landscape left");
        self.lblInfo.text = @"Landscape left";
    } else if (orientation == UIInterfaceOrientationLandscapeRight) {
        NSLog(@"Landscape right");
        self.lblInfo.text = @"Landscape right";
    } else if (orientation == UIInterfaceOrientationPortrait) {
        NSLog(@"Portrait");
        self.lblInfo.text = @"Portrait";
    } else if (orientation == UIInterfaceOrientationPortraitUpsideDown) {
        NSLog(@"Upside down");
        self.lblInfo.text = @"Upside down";
    }
}

Mieux que d'utiliser UIDevice, thx

InformationsquelleAutor rajat

0

Et si vous voulez simplement savoir si l'appareil est en mode paysage ou portrait, une solution très simple (rapide):
```
var orientation = "portrait"
if UIScreen.main.bounds.size.width > UIScreen.main.bounds.size.height {
   orientation = "landscape"
}
```
InformationsquelleAutor Shredder2794

Vous devez vous connecter pour publier un commentaire.