Est-ce que [UIScreen mainScreen] .bounds.size devient dépendant de l'orientation dans iOS8?

J'ai exécuté le code suivant dans iOS 7 et iOS 8:

UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];
BOOL landscape = (orientation == UIInterfaceOrientationLandscapeLeft || orientation == UIInterfaceOrientationLandscapeRight);
NSLog(@"Currently landscape: %@, width: %.2f, height: %.2f", 
      (landscape ? @"Yes" : @"No"), 
      [[UIScreen mainScreen] bounds].size.width, 
      [[UIScreen mainScreen] bounds].size.height);

Voici le résultat d'iOS 8:

Currently landscape: No, width: 320.00, height: 568.00
Currently landscape: Yes, width: 568.00, height: 320.00

Comparé au résultat dans iOS 7:

Currently landscape: No, width: 320.00, height: 568.00
Currently landscape: Yes, width: 320.00, height: 568.00

Existe-t-il une documentation spécifiant ce changement? Ou est-ce un bogue temporaire dans les API iOS 8?

Oui, cela dépend de l'orientation dans iOS8, pas un bogue. Vous pouvez consulter la session 214 de la WWDC 2014 pour plus d'informations: «Afficher les avancées du contrôleur dans iOS 8»

Citation de la présentation:

UIScreen est désormais orienté interface:

• [UIScreen bounds] désormais orienté interface
• [UIScreen applicationFrame] désormais orienté interface
• Les notifications par cadre de la barre d'état sont orientées vers l'interface
• Les notifications de cadre de clavier sont orientées vers l'interface

Oui, cela dépend de l'orientation dans iOS8.

J'ai écrit une méthode Util pour résoudre ce problème pour les applications qui doivent prendre en charge les anciennes versions du système d'exploitation.

+ (CGSize)screenSize {
    CGSize screenSize = [UIScreen mainScreen].bounds.size;
    if ((NSFoundationVersionNumber <= NSFoundationVersionNumber_iOS_7_1) && UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation)) {
        return CGSizeMake(screenSize.height, screenSize.width);
    }
    return screenSize;
}

Oui, en effet, la taille de l'écran dépend désormais de l'orientation dans iOS 8. Parfois, cependant, il est souhaitable d'obtenir une taille fixée à l'orientation portrait. Voici comment je le fais.

+ (CGRect)screenBoundsFixedToPortraitOrientation {
    UIScreen *screen = [UIScreen mainScreen];

    if ([screen respondsToSelector:@selector(fixedCoordinateSpace)]) {
                    return [screen.coordinateSpace convertRect:screen.bounds toCoordinateSpace:screen.fixedCoordinateSpace];
    } 
    return screen.bounds;
}

Oui, cela dépend désormais de l'orientation.

Je préfère la méthode ci-dessous pour obtenir la taille de l'écran d'une manière indépendante de l'orientation à certaines des réponses ci-dessus, à la fois parce qu'elle est plus simple et parce qu'elle ne dépend d'aucun code d'orientation (dont l'état peut dépendre du heure de leur appel) ou lors de la vérification de version. Vous voudrez peut-être le nouveau comportement d'iOS 8, mais cela fonctionnera si vous en avez besoin pour être stable sur toutes les versions d'iOS.

+(CGSize)screenSizeOrientationIndependent {
     CGSize screenSize = [UIScreen mainScreen].bounds.size;
     return CGSizeMake(MIN(screenSize.width, screenSize.height), MAX(screenSize.width, screenSize.height));
}

Lié à cette question car elle a résolu mon problème, voici deux définitions que j'utilise pour les calculs de largeur et de hauteur d'écran:

#define SCREEN_WIDTH (IOS_VERSION_LOWER_THAN_8 ? (UIInterfaceOrientationIsPortrait([UIApplication sharedApplication].statusBarOrientation) ? [[UIScreen mainScreen] bounds].size.width : [[UIScreen mainScreen] bounds].size.height) : [[UIScreen mainScreen] bounds].size.width)

#define SCREEN_HEIGHT (IOS_VERSION_LOWER_THAN_8 ? (UIInterfaceOrientationIsPortrait([UIApplication sharedApplication].statusBarOrientation) ? [[UIScreen mainScreen] bounds].size.height : [[UIScreen mainScreen] bounds].size.width) : [[UIScreen mainScreen] bounds].size.height)

#define IOS_VERSION_LOWER_THAN_8 (NSFoundationVersionNumber <= NSFoundationVersionNumber_iOS_7_1)

Si vous prenez en charge à la fois iOS 7 et iOS 8, c'est la meilleure solution à ce problème.

Vous pouvez utiliser nativeBounds(indépendamment de l'orientation)

nativeBounds

Le rectangle englobant de l'écran physique, mesuré en pixels. (lecture seulement)

Déclaration SWIFT

  var nativeBounds: CGRect { get }

Ce rectangle est basé sur l'appareil dans une orientation portrait vers le haut. Cette valeur ne change pas lorsque l'appareil tourne.

Détection de la hauteur de l'appareil:

if UIScreen.mainScreen().nativeBounds.height == 960.0 {

}

Détection de la largeur de l'appareil:

if UIScreen.mainScreen().nativeBounds.width == 640.0 {

}

Ce n'est pas un bogue dans le SDK iOS 8. Ils ont fait dépendre l'orientation de l'interface des limites. Selon votre question sur une référence ou une documentation sur ce fait, je vous recommanderai fortement de regarder la View Controller Advancements in iOS 8session 214 de la WWDC 2014 . La partie la plus intéressante (selon vos doutes) est celle Screen Coordinatesqui commence à 50h45.

Oui, cela dépend de l'orientation dans iOS8.

Voici comment vous pouvez avoir un moyen cohérent de lire les limites à la manière d'iOS 8 sur les versions du SDK et du système d'exploitation.

#ifndef NSFoundationVersionNumber_iOS_7_1
# define NSFoundationVersionNumber_iOS_7_1 1047.25
#endif

@implementation UIScreen (Legacy)

// iOS 8 way of returning bounds for all SDK's and OS-versions
- (CGRect)boundsRotatedWithStatusBar
{
    static BOOL isNotRotatedBySystem;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        BOOL OSIsBelowIOS8 = [[[UIDevice currentDevice] systemVersion] floatValue] < 8.0;
        BOOL SDKIsBelowIOS8 = floor(NSFoundationVersionNumber) <= NSFoundationVersionNumber_iOS_7_1;
        isNotRotatedBySystem = OSIsBelowIOS8 || SDKIsBelowIOS8;
    });

    BOOL needsToRotate = isNotRotatedBySystem && UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation);
    if(needsToRotate)
    {
        CGRect screenBounds = [self bounds];
        CGRect bounds = screenBounds;
        bounds.size.width = screenBounds.size.height;
        bounds.size.height = screenBounds.size.width;
        return bounds;
    }
    else
    {
        return [self bounds];
    }
}

@end

Ma solution est une combinaison de MaxK et hfossli. J'ai fait cette méthode sur une catégorie d'UIScreen et il n'y a pas de vérification de version (ce qui est une mauvaise pratique):

//Always return the iOS8 way - i.e. height is the real orientation dependent height
+ (CGRect)screenBoundsOrientationDependent {
    UIScreen *screen = [UIScreen mainScreen];
    CGRect screenRect;
    if (![screen respondsToSelector:@selector(fixedCoordinateSpace)] && UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation)) {
        screenRect = CGRectMake(screen.bounds.origin.x, screen.bounds.origin.y, screen.bounds.size.height, screen.bounds.size.width);
    } else {
        screenRect = screen.bounds;
    }

    return screenRect;
}

J'avais besoin d'une fonction d'aide rapide qui gardait le même comportement qu'iOS7 sous iOS8 - cela m'a permis d'échanger mes [[UIScreen mainScreen] bounds]appels et de ne pas toucher d'autre code ...

+ (CGRect)iOS7StyleScreenBounds {
    CGRect bounds = [UIScreen mainScreen].bounds;
    if (([[[UIDevice currentDevice] systemVersion] floatValue] >= 8.0) && UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation)) {
        bounds.size = CGSizeMake(bounds.size.height, bounds.size.width);
    }
        return bounds;
}

La méthode ci-dessous peut être utilisée pour trouver les limites de l'écran pour une orientation donnée, indépendamment de la version iOS. Cette méthode renverra les limites en fonction de la taille de l'écran de l'appareil et donnera la même valeur CGRect indépendamment de la version iOS.

- (CGRect)boundsForOrientation:(UIInterfaceOrientation)orientation {

    CGFloat width   = [[UIScreen mainScreen] bounds].size.width;
    CGFloat height  = [[UIScreen mainScreen] bounds].size.height;

    CGRect bounds = CGRectZero;

    if (UIInterfaceOrientationIsLandscape(orientation)) {
        bounds.size = CGSizeMake(MAX(width, height), MIN(width, height));
    } else {
        bounds.size = CGSizeMake(MIN(width, height), MAX(width, height));
    }

    return bounds;
}

// For the below example, bounds will have the same value if you run the code on iOS 8.x or below versions.
CGRect bounds = [self boundsForOrientation:UIInterfaceOrientationPortrait]; 

C'est ce que j'ai utilisé pour calculer le bon rect:

UIScreen* const mainScreen = [UIScreen mainScreen];
CGRect rect = [mainScreen bounds];
#ifdef __IPHONE_8_0
if ([mainScreen respondsToSelector:@selector(coordinateSpace)])
{
    if ([mainScreen respondsToSelector:@selector(fixedCoordinateSpace)])
    {
        id tmpCoordSpace = [mainScreen coordinateSpace];
        id tmpFixedCoordSpace = [mainScreen fixedCoordinateSpace];

        if ([tmpCoordSpace respondsToSelector:@selector(convertRect:toCoordinateSpace:)])
        {
            rect = [tmpCoordSpace convertRect:rect toCoordinateSpace: tmpFixedCoordSpace];
        }
    }
}
#endif

L'ajout de la version rapide d'une excellente fonction cbartel a répondu ci-dessus.

func screenSize() -> CGSize {
    let screenSize = UIScreen.mainScreen().bounds.size
    if (NSFoundationVersionNumber <= NSFoundationVersionNumber_iOS_7_1) && UIInterfaceOrientationIsLandscape(UIApplication.sharedApplication().statusBarOrientation) {
        return CGSizeMake(screenSize.height, screenSize.width)
    }
    return screenSize
}

Mon problème était lié au cadre UIWindows qui allait en moins. Donc, faites le code comme ci-dessous dans MyViewController - (NSUInteger) supportedInterfaceOrientations, méthode

[[UIApplication sharedApplication] setStatusBarHidden:NO];

[self.view setFrame:CGRectMake(0, 0, [[UIScreen mainScreen] bounds].size.width, [[UIScreen mainScreen] bounds].size.height)];

[appDel.window setFrame:CGRectMake(0, 0, [[UIScreen mainScreen] bounds].size.width, [[UIScreen mainScreen] bounds].size.height)];

Et son travail pour moi l'essayer.

iOS 8 ou supérieur

Une solution pour ceux qui veulent connaître la taille de l'écran en points (l'écran de 3,5 pouces a 320 × 480 points, l'écran de 4,0 pouces a 320 × 568 points, etc.) serait

- (CGSize)screenSizeInPoints
{
    CGFloat width = [[UIScreen mainScreen] bounds].size.width;
    CGFloat height = [[UIScreen mainScreen] bounds].size.height;

    if (width > height) {
        return CGSizeMake(height, width);
    }
    else {
        return [[UIScreen mainScreen] bounds].size;
    }
}

Une chose que j'ai notée est que l' ordre des orientations d'interface prises en charge dans Info.plist importe. J'ai eu le problème de cette question avec mon application (qui fait l'orientation dans le code), mais je n'ai spécifié nulle part que l'orientation par défaut est Portrait.

Je pensais que l'orientation par défaut était Portrait en tout cas.

La réorganisation des itens dans Info.plist, en mettant Portrait en premier, a restauré le comportement attendu.

Cela donnera le bon appareil dans iOS7 et iOS8 à la fois,

#define SYSTEM_VERSION_LESS_THAN(v) ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)
#define IS_PORTRAIT         UIDeviceOrientationIsPortrait([UIDevice currentDevice].orientation)

+ (BOOL)isIPHONE4{

// < iOS 8.0
if(SYSTEM_VERSION_LESS_THAN(@"8.0")){

        if ([self getDeviceWidth] == 320.0 && [self getDeviceHeight] == 480.0) {
            return YES;
        } else {
            return NO;
        }

// >= iOS 8.0
}else{

    if(IS_PORTRAIT){

        if ([self getDeviceWidth] == 320.0 && [self getDeviceHeight] == 480.0) {
            return YES;
        } else {
            return NO;
        }

    }else{

        if ([self getDeviceWidth] == 480.0 && [self getDeviceHeight] == 320.0) {
            return YES;
        } else {
            return NO;
        }

    }

}


}

+ (BOOL)isIPHONE5{


// < iOS 8.0
if(SYSTEM_VERSION_LESS_THAN(@"8.0")){

    if ([self getDeviceWidth] == 320.0 && [self getDeviceHeight] == 568.0) {
        return YES;
    } else {
        return NO;
    }

    // >= iOS 8.0
}else{

    if(IS_PORTRAIT){

        if ([self getDeviceWidth] == 320.0 && [self getDeviceHeight] == 568.0) {
            return YES;
        } else {
            return NO;
        }

    }else{

        if ([self getDeviceWidth] == 568.0 && [self getDeviceHeight] == 320.0) {
            return YES;
        } else {
            return NO;
        }

    }

}

}

+ (BOOL)isIPHONE6{

// < iOS 8.0
if(SYSTEM_VERSION_LESS_THAN(@"8.0")){

    if ([self getDeviceWidth] == 375.0 && [self getDeviceHeight] == 667.0) {
        return YES;
    } else {
        return NO;
    }

    // >= iOS 8.0
}else{

    if(IS_PORTRAIT){

        if ([self getDeviceWidth] == 375.0 && [self getDeviceHeight] == 667.0) {
            return YES;
        } else {
            return NO;
        }

    }else{

        if ([self getDeviceWidth] == 667.0 && [self getDeviceHeight] == 375.0) {
            return YES;
        } else {
            return NO;
        }

    }

}


}
+ (BOOL)isIPHONE6Plus{


// < iOS 8.0
if(SYSTEM_VERSION_LESS_THAN(@"8.0")){

    if ([self getDeviceWidth] == 414.0 && [self getDeviceHeight] == 736.0) {
        return YES;
    } else {
        return NO;
    }

    // >= iOS 8.0
}else{

    if(IS_PORTRAIT){

        if ([self getDeviceWidth] == 414.0 && [self getDeviceHeight] == 736.0) {
            return YES;
        } else {
            return NO;
        }

    }else{

        if ([self getDeviceWidth] == 736.0 && [self getDeviceHeight] == 414.0) {
            return YES;
        } else {
            return NO;
        }

    }

}


}

+ (CGFloat)getDeviceHeight{

//NSLog(@"Device width: %f",[UIScreen mainScreen].bounds.size.height);
return [UIScreen mainScreen].bounds.size.height;
}
+ (CGFloat)getDeviceWidth{

//NSLog(@"Device width: %f",[UIScreen mainScreen].bounds.size.height);
return [UIScreen mainScreen].bounds.size.width;
}

// Vous pouvez également ajouter d'autres appareils (ieiPad).

Utilisé la solution de mnemia légèrement modifiée, celle-là sans vérification de version iOS, utilisant min / max sur les limites de l'écran principal.
Il me fallait un CGRectsi obtenu CGRectde limites mainScreen et changé size.width=min(w,h), size.height=max(w,h). Ensuite , j'ai appelé ce système d' exploitation indépendant get CGRectfonction en deux endroits dans mon code, où j'obtenir la taille de l' écran pour OpenGL, des touches , etc. Avant de fixer j'ai eu 2 problèmes - sur IOS 8.x en position d'affichage en mode paysage de OpenGLvue était incorrecte: 1 / 4 de plein écran dans la partie inférieure gauche. Et les secondes touches ont renvoyé des valeurs invalides. Les deux problèmes ont été résolus comme expliqué. Merci!