O [UIScreen mainScreen] .bounds.size está se tornando dependente da orientação no iOS8?

Executei o seguinte código no iOS 7 e 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);

A seguir, o resultado do iOS 8:

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

Comparando com o resultado no iOS 7:

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

Existe alguma documentação especificando essa alteração? Ou é um bug temporário nas APIs do iOS 8?

Sim, é dependente da orientação no iOS8, não um bug. Você pode revisar a sessão 214 da WWDC 2014 para obter mais informações: "Exibir avanços do controlador no iOS 8"

Citação da apresentação:

O UIScreen agora é orientado por interface:

• [Limites UIScreen] agora orientado a interface
• [UIScreen applicationFrame] agora orientado a interface
• As notificações do quadro da barra de status são orientadas à interface
• As notificações do quadro do teclado são orientadas à interface

Sim, depende da orientação no iOS8.

Eu escrevi um método Util para resolver esse problema para aplicativos que precisam suportar versões mais antigas do sistema operacional.

+ (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;
}

Sim, na verdade, o tamanho da tela agora depende da orientação no iOS 8. Às vezes, porém, é desejável obter um tamanho fixo para a orientação retrato. Aqui está como eu faço isso.

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

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

Sim, agora depende da orientação.

Prefiro o método abaixo para obter o tamanho da tela de maneira independente da orientação do que algumas das respostas acima, tanto porque é mais simples quanto porque não depende de nenhum código de orientação (cujo estado pode depender do quando são chamados) ou na verificação de versão. Você pode querer o novo comportamento do iOS 8, mas isso funcionará se você precisar ser estável em todas as versões do iOS.

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

Relacionado a esta pergunta, pois resolveu meu problema, aqui duas definem que eu uso para cálculos de largura e altura da tela:

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

Se você suporta o iOS 7 e o iOS 8, esta é a melhor solução para esse problema.

Você pode usar nativeBounds(independente da orientação)

nativeBounds

O retângulo delimitador da tela física, medido em pixels. (somente leitura)

Declaração SWIFT

  var nativeBounds: CGRect { get }

Esse retângulo é baseado no dispositivo em uma orientação de retrato para cima. Este valor não muda à medida que o dispositivo gira.

Detectando a altura do dispositivo:

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

}

Detectando a largura do dispositivo:

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

}

Não é um bug no iOS 8 SDK. Eles estabeleceram limites na orientação da interface. De acordo com sua pergunta sobre alguma referência ou documentação para esse fato, eu recomendo que você assista à View Controller Advancements in iOS 8214 sessão da WWDC 2014 . A parte mais interessante (de acordo com suas dúvidas) é a Screen Coordinatesque começa às 50:45.

Sim, depende da orientação no iOS8.

Veja como você pode ter uma maneira consistente de ler os limites do iOS 8 nas versões do SDK e do SO.

#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

Minha solução é uma combinação de MaxK e hfossli. Eu fiz esse método em uma categoria do UIScreen e ele não possui verificações de versão (o que é uma prática ruim):

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

Eu precisava de uma função de ajuda rápida que mantivesse o mesmo comportamento do iOS7 no iOS8 - isso me permitia trocar minhas [[UIScreen mainScreen] bounds]chamadas e não tocar em outro código ...

+ (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;
}

O método abaixo pode ser usado para encontrar os limites da tela para uma determinada orientação, independentemente da versão do iOS. Este método retornará os limites com base no tamanho da tela do dispositivo e fornecerá o mesmo valor de CGRect independente da versão do 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]; 

Isso é o que eu usei para calcular o correto correto:

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

Apenas adicionando a versão rápida de uma excelente função cbartel, respondida acima.

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
}

Meu problema estava relacionado ao quadro UIWindows, que estava diminuindo. Por isso, criei o código abaixo no MyViewController - (NSUInteger) Método supportedInterfaceOrientations

[[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)];

E seu trabalho para mim, tente.

iOS 8 ou superior

Uma solução para quem deseja descobrir o tamanho da tela em pontos (a tela de 3,5 polegadas possui 320 × 480 pontos, a tela de 4,0 polegadas possui 320 × 568 pontos etc.) seria

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

Uma coisa que observei é que a ordem das orientações de interface suportadas no Info.plist é importante. Eu obtive o problema desta pergunta com meu aplicativo (que faz orientação no código), mas não especifiquei em nenhum lugar que a orientação padrão seja Portrait.

Eu pensei que a orientação padrão era Retrato em qualquer caso.

Reorganizar itens no Info.plist, colocando o Portrait em primeiro lugar, restaurou o comportamento esperado.

Isso fornecerá o dispositivo correto no iOS7 e iOS8 ,

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

// Você também pode adicionar mais dispositivos (ieiPad).

Usou a solução de mnemia levemente modificada, aquela sem verificação de versão do iOS, usando min / max nos limites da tela principal.
Eu precisava de um CGRect, então temos CGRectde limites MainScreen e mudou size.width=min(w,h), size.height=max(w,h). Em seguida, chamei a CGRectfunção get independente do sistema operacional em dois lugares no meu código, onde obtive o tamanho da tela OpenGL, toques etc. Antes de corrigir, eu tinha dois problemas - no IOS 8.x no modo paisagem, a posição de OpenGLexibição do modo paisagem estava incorreta: 1 / 4 de tela cheia na parte inferior esquerda. E os segundos toques retornaram valores inválidos. Ambos os problemas foram corrigidos conforme explicado. Obrigado!