Wird [UIScreen mainScreen] .bounds.size in iOS8 orientierungsabhängig?

Lief ich den folgenden code in iOS 7 und 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);

Im folgenden wird das Ergebnis aus iOS 8:

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

Vergleich zu dem Ergebnis in iOS 7:

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

Gibt es keine Dokumentation, die Angabe dieser änderung? Oder ist es ein temporärer bug in iOS 8 APIs?

InformationsquelleAutor der Frage lwxted | 2014-06-10

170

Ja, es ist die Ausrichtung-abhängig in iOS8, kein Fehler. Sie könnten Rückblick 214 von der WWDC 2014 für mehr Infos: "View-Controller Fortschritte in iOS 8"

Zitat aus der Präsentation:

UIScreen ist nun die Schnittstelle orientiert:
- [UIScreen Grenzen] jetzt interface-orientierte
- [UIScreen applicationFrame] jetzt interface-orientierte
- Status bar frame-Benachrichtigungen sind interface-orientierte
- Tastatur-Rahmen-Benachrichtigungen sind interface-orientierte
InformationsquelleAutor der Antwort vhristoskov

Ja, es ist die Ausrichtung-abhängig in iOS8.

Schrieb ich eine Util-Methode, um dieses Problem zu beheben, für apps die Unterstützung für ältere Versionen des OS.

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

InformationsquelleAutor der Antwort cbartel

Ja, in der Tat, der Bildschirm ist jetzt Orientierung abhängig in iOS 8. Manchmal ist es jedoch gewünscht, erhalten Sie eine Feste Größe-in das hochformat. Hier ist, wie ich es mache.

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

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

InformationsquelleAutor der Antwort MaxK

32

Ja, es ist nun abhängig von der Orientierung.

Ich bevorzuge die unten Methode, die Bildschirm-Größe in eine Orientierungs-unabhängigen Weg zu einigen der oben genannten Antworten, weil es einfacher ist und weil es nicht abhängig von der Ausrichtung code (der Staat, das sein kann, abhängig von der Zeit, in der Sie genannt werden) oder auf version überprüfen. Sie können die neue iOS-8-Verhalten, aber das wird funktionieren, wenn Sie es brauchen, um stabil auf allen Versionen von iOS.
```
+(CGSize)screenSizeOrientationIndependent {
     CGSize screenSize = [UIScreen mainScreen].bounds.size;
     return CGSizeMake(MIN(screenSize.width, screenSize.height), MAX(screenSize.width, screenSize.height));
}
```
InformationsquelleAutor der Antwort mnemia

Sich auf diese Frage beziehen, wie es mein problem gelöst, hier zwei definiert, die ich für Bildschirm-Breite und Höhe-Berechnungen:

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

Wenn Sie Unterstützung sowohl für iOS 7 und iOS 8, das ist die beste Lösung für dieses problem.

InformationsquelleAutor der Antwort Antoine

9

Können Sie nativeBounds (Orientierung-unabhängig)

nativeBounds
Das umschließende Rechteck des physischen Bildschirms in Pixeln gemessen.
(nur Lesen)

Erklärung SWIFT
```
  var nativeBounds: CGRect { get }
```
Dieses Rechteck wird auf der Basis der Vorrichtung in einer hochformat-Ausrichtung. Diese
Wert ändert sich nicht, wenn das Gerät dreht.
Erkennen des Geräts Höhe:
```
if UIScreen.mainScreen().nativeBounds.height == 960.0 {

}
```
Erkennen des Geräts Breite:
```
if UIScreen.mainScreen().nativeBounds.width == 640.0 {

}
```
InformationsquelleAutor der Antwort Leo Dabus
8

Ist es nicht ein bug in iOS 8 SDK. Machten Sie Grenzen Schnittstelle Orientierung angewiesen. Nach Ihrer Frage, einen Hinweis oder Dokumentation auf diesen Umstand werde ich empfehlen, Sie zu beobachten View Controller Advancements in iOS 8 es ist 214 Sitzung vom WWDC 2014. Der interessanteste Teil (nach deiner Zweifel) ist Screen Coordinates beginnt bei 50:45.

InformationsquelleAutor der Antwort Julian Król

Ja, es ist die Ausrichtung-abhängig in iOS8.

Hier ist, wie können Sie eine concistent Art des Lesens heraus-Grenzen in einer iOS-8-Mode über SDK und OS-Versionen.

#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

InformationsquelleAutor der Antwort hfossli

Meine Lösung ist eine Kombination von MaxK und hfossli. Ich habe diese Methode auf eine Kategorie von UIScreen und es hat keine überprüfung der version (das ist eine schlechte Praxis):

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

InformationsquelleAutor der Antwort Uzair Khan

Brauchte ich eine schnelle Helfer-Funktion gehalten, dass das gleiche Verhalten wie unter iOS7 iOS8 - dies erlaubte mir zu tauschen meine [[UIScreen mainScreen] bounds] nennt und nicht berühren anderen 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;
}

InformationsquelleAutor der Antwort Joe Booth

Den folgenden Verfahren verwendet werden können, finden Sie die Bildschirm-Grenzen für einen bestimmten Orientierung, unabhängig von der iOS-version. Diese Methode zurück, die Grenzen basierend auf der Bildschirmgröße des Geräts an, und geben die gleiche CGRect-Wert unabhängig von der iOS-version.

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

InformationsquelleAutor der Antwort Mohammed MT

Ist das, was ich verwendet, um zu berechnen die richtige 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

InformationsquelleAutor der Antwort hhamm

Nur das hinzufügen der swift-version eine hervorragende cbartel Funktion beantwortet wurden.

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
}

InformationsquelleAutor der Antwort Martin Koles

Meine Frage bezog sich auf UIWindows Rahmen, die im Begriff war im minus.
So machte Sie den code wie unten im MyViewController
-(NSUInteger)supportedInterfaceOrientations Methode

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

Und seine Arbeit für mich es versuchen.

InformationsquelleAutor der Antwort Hardik Mamtora

0

Eine Sache, die ich bemerkt ist, die um der unterstützten Ausrichtungen in der Info.plist nicht egal. Ich hab das problem, diese Frage mit meiner app (das macht die Orientierung im code), aber ich habe nicht überall angeben, dass die Standardausrichtung Hochformat.

Dachte ich, die Standard-Orientierung war Portrait auf jeden Fall.

Neuordnung itens in Info.plist, putting-Porträt ersten, wieder das erwartete Verhalten.

InformationsquelleAutor der Antwort epx

Diese geben das Gerät korrekt in iOS7 und iOS8 beide,

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

//Sie können mehr Geräte als auch(ich.e.iPad).

InformationsquelleAutor der Antwort Zaid Pathan

iOS 8 oder der oberen

Lösung für diejenigen, die wollen, um herauszufinden, die Bildschirm-Größe in Punkten (3,5 Zoll Bildschirm mit 320 × 480 Punkte, 4.0 Zoll Bildschirm mit 320 × 568 Punkten, etc) wäre

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

InformationsquelleAutor der Antwort azimov

0

Verwendet leicht modifizierte mnemia die Lösung ist, dass man ohne iOS-version überprüfen, mit min - /max-on mainscreen Grenzen gesetzt.

Ich brauchte eine CGRect so bekam CGRect vom mainscreen Grenzen und verändert size.width=min(w,h), size.height=max(w,h). Dann rief ich, dass OS-unabhängig zu bekommen CGRect Funktion an zwei stellen in meinem code, wo bekomme ich Bildschirm Größe für OpenGL, Berührungen. Vor dem Update hatte ich 2 Probleme - IOS-8.x im landscape-Modus anzeigen der position von OpenGL Ansicht war falsch: 1/4 der vollen Bildschirm in der linken unteren Teil. Und zweitens berührt zurückgegeben ungültige Werte. Beide Probleme wurden behoben, wie erläutert. Danke!

InformationsquelleAutor der Antwort NoAngel

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.