Wie erhalte ich die Bildschirmbreite und -höhe in iOS?

Wie kann man die Abmessungen des Bildschirms in iOS erhalten?

Derzeit benutze ich:

lCurrentWidth = self.view.frame.size.width;
lCurrentHeight = self.view.frame.size.height;

in viewWillAppear:undwillAnimateRotationToInterfaceOrientation:duration:

Das erste Mal bekomme ich die gesamte Bildschirmgröße. Das zweite Mal bekomme ich den Bildschirm ohne die Navigationsleiste.

Wie kann man die Abmessungen des Bildschirms in iOS erhalten?

Das Problem mit dem von Ihnen geposteten Code besteht darin, dass Sie auf die Ansichtsgröße zählen, die der des Bildschirms entspricht, und wie Sie gesehen haben, ist dies nicht immer der Fall. Wenn Sie die Bildschirmgröße benötigen, sollten Sie sich das Objekt ansehen, das den Bildschirm selbst darstellt:

CGRect screenRect = [[UIScreen mainScreen] bounds];
CGFloat screenWidth = screenRect.size.width;
CGFloat screenHeight = screenRect.size.height;

Update für geteilte Ansicht: In Kommentaren fragte Dmitry:

Wie kann ich die Größe des Bildschirms in der geteilten Ansicht ermitteln?

Der oben angegebene Code gibt die Größe des Bildschirms an, auch im geteilten Bildschirmmodus. Wenn Sie den geteilten Bildschirmmodus verwenden, ändert sich das Fenster Ihrer App. Wenn der obige Code nicht die erwarteten Informationen enthält, sehen Sie wie beim OP das falsche Objekt. In diesem Fall sollten Sie jedoch das Fenster anstelle des Bildschirms wie folgt betrachten:

CGRect windowRect = self.view.window.frame;
CGFloat windowWidth = windowRect.size.width;
CGFloat windowHeight = windowRect.size.height;

Swift 4.2

let screenRect = UIScreen.main.bounds
let screenWidth = screenRect.size.width
let screenHeight = screenRect.size.height

// split screen            
let windowRect = self.view.window?.frame
let windowWidth = windowRect?.size.width
let windowHeight = windowRect?.size.height

Achtung, [UIScreen mainScreen] enthält auch die Statusleiste. Wenn Sie den Rahmen für Ihre Anwendung abrufen möchten (ohne Statusleiste), sollten Sie ihn verwenden

+ (CGFloat) window_height   {
    return [UIScreen mainScreen].applicationFrame.size.height;
}

+ (CGFloat) window_width   {
    return [UIScreen mainScreen].applicationFrame.size.width;
}

Ich habe einige der oben genannten Objective-C-Antworten in Swift-Code übersetzt. Jede Übersetzung wird mit einem Verweis auf die ursprüngliche Antwort fortgesetzt.

Hauptantwort

let screen = UIScreen.main.bounds
let screenWidth = screen.size.width
let screenHeight = screen.size.height

Einfache Funktionsantwort

func windowHeight() -> CGFloat {
    return UIScreen.mainScreen().applicationFrame.size.height
}

func windowWidth() -> CGFloat {
    return UIScreen.mainScreen().applicationFrame.size.width
}

Antwort zur Geräteorientierung

var screenHeight : CGFloat
let statusBarOrientation = UIApplication.sharedApplication().statusBarOrientation
// it is important to do this after presentModalViewController:animated:
if (statusBarOrientation != UIInterfaceOrientation.Portrait
    && statusBarOrientation != UIInterfaceOrientation.PortraitUpsideDown){
    screenHeight = UIScreen.mainScreen().applicationFrame.size.width
} else {
    screenHeight = UIScreen.mainScreen().applicationFrame.size.height
}

Antwort protokollieren

let screenWidth = UIScreen.mainScreen().bounds.size.width
let screenHeight = UIScreen.mainScreen().bounds.size.height
println("width: \(screenWidth)")
println("height: \(screenHeight)")

Ich habe diese praktischen Methoden bereits verwendet:

- (CGRect)getScreenFrameForCurrentOrientation {
    return [self getScreenFrameForOrientation:[UIApplication sharedApplication].statusBarOrientation];
}

- (CGRect)getScreenFrameForOrientation:(UIInterfaceOrientation)orientation {

    CGRect fullScreenRect = [[UIScreen mainScreen] bounds];

    // implicitly in Portrait orientation.
    if (UIInterfaceOrientationIsLandscape(orientation)) {
      CGRect temp = CGRectZero;
      temp.size.width = fullScreenRect.size.height;
      temp.size.height = fullScreenRect.size.width;
      fullScreenRect = temp;
    }

    if (![[UIApplication sharedApplication] statusBarHidden]) {
      CGFloat statusBarHeight = 20; // Needs a better solution, FYI statusBarFrame reports wrong in some cases..
      fullScreenRect.size.height -= statusBarHeight;
    }

    return fullScreenRect;
} 

Mir ist klar, dass dies ein alter Beitrag ist, aber manchmal finde ich es nützlich, Konstanten wie diese zu definieren, damit ich mir darüber keine Sorgen machen muss:

#define DEVICE_SIZE [[[[UIApplication sharedApplication] keyWindow] rootViewController].view convertRect:[[UIScreen mainScreen] bounds] fromView:nil].size

Die obige Konstante sollte unabhängig von der Ausrichtung des Geräts die richtige Größe zurückgeben. Dann ist das Abrufen der Abmessungen so einfach wie:

lCurrentWidth = DEVICE_SIZE.width;
lCurrentHeight = DEVICE_SIZE.height;

Es ist sehr, sehr einfach Ihr Gerät Größe zu erhalten sowie Berücksichtigung der Orientierung:

// grab the window frame and adjust it for orientation
UIView *rootView = [[[UIApplication sharedApplication] keyWindow] 
                                   rootViewController].view;
CGRect originalFrame = [[UIScreen mainScreen] bounds];
CGRect adjustedFrame = [rootView convertRect:originalFrame fromView:nil];

Wir müssen auch die Ausrichtung des Geräts berücksichtigen:

CGFloat screenHeight;
// it is important to do this after presentModalViewController:animated:
if ([[UIApplication sharedApplication] statusBarOrientation] == UIDeviceOrientationPortrait || [[UIApplication sharedApplication] statusBarOrientation] == UIDeviceOrientationPortraitUpsideDown){
    screenHeight = [UIScreen mainScreen].applicationFrame.size.height;
}
else{
    screenHeight = [UIScreen mainScreen].applicationFrame.size.width;
}

NSLog(@"%.0f", [[UIScreen mainScreen] bounds].size.width);
NSLog(@"%.0f", [[UIScreen mainScreen] bounds].size.height);

Hier habe ich für Swift 3 aktualisiert

applicationFrame ist von iOS 9 veraltet

In schnell drei haben sie entfernt () und sie haben einige Namenskonventionen geändert, Sie können hier Link verweisen

func windowHeight() -> CGFloat {
    return UIScreen.main.bounds.size.height
}

func windowWidth() -> CGFloat {
    return UIScreen.main.bounds.size.width
}

Die moderne Antwort:

Wenn Ihre App die geteilte Ansicht auf dem iPad unterstützt, wird dieses Problem etwas kompliziert. Sie benötigen die Fenstergröße, nicht die des Bildschirms, der 2 Apps enthalten kann. Die Größe des Fensters kann auch während des Betriebs variieren.

Verwenden Sie die Größe des Hauptfensters der App:

UIApplication.shared.delegate?.window??.bounds.size ?? .zero

Hinweis: Die oben beschriebene Methode kann einen falschen Wert erhalten, bevor das Fenster beim Start zum Schlüsselfenster wird. Wenn Sie nur Breite benötigen, wird die folgende Methode sehr empfohlen :

UIApplication.shared.statusBarFrame.width

Die alte Lösung verwendet UIScreen.main.boundsdie Grenzen des Geräts zurück. Wenn Ihre App im geteilten Ansichtsmodus ausgeführt wird, werden die falschen Abmessungen angezeigt.

self.view.window In der heißesten Antwort kann die Größe falsch sein, wenn die App 2 oder mehr Fenster enthält und das Fenster klein ist.

Nutzen Sie diese Structs, um nützliche Informationen zum aktuellen Gerät in Swift 3.0 zu erhalten

struct ScreenSize { // Answer to OP's question

    static let SCREEN_WIDTH         = UIScreen.main.bounds.size.width
    static let SCREEN_HEIGHT        = UIScreen.main.bounds.size.height
    static let SCREEN_MAX_LENGTH    = max(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
    static let SCREEN_MIN_LENGTH    = min(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)

}

struct DeviceType { //Use this to check what is the device kind you're working with

    static let IS_IPHONE_4_OR_LESS  = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH < 568.0
    static let IS_IPHONE_SE         = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 568.0
    static let IS_IPHONE_7          = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 667.0
    static let IS_IPHONE_7PLUS      = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 736.0
    static let IS_IPHONE_X          = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 812.0
    static let IS_IPAD              = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1024.0

}


struct iOSVersion { //Get current device's iOS version

    static let SYS_VERSION_FLOAT  = (UIDevice.current.systemVersion as NSString).floatValue
    static let iOS7               = (iOSVersion.SYS_VERSION_FLOAT >= 7.0 && iOSVersion.SYS_VERSION_FLOAT < 8.0)
    static let iOS8               = (iOSVersion.SYS_VERSION_FLOAT >= 8.0 && iOSVersion.SYS_VERSION_FLOAT < 9.0)
    static let iOS9               = (iOSVersion.SYS_VERSION_FLOAT >= 9.0 && iOSVersion.SYS_VERSION_FLOAT < 10.0)
    static let iOS10              = (iOSVersion.SYS_VERSION_FLOAT >= 10.0 && iOSVersion.SYS_VERSION_FLOAT < 11.0)
    static let iOS11              = (iOSVersion.SYS_VERSION_FLOAT >= 11.0 && iOSVersion.SYS_VERSION_FLOAT < 12.0)
    static let iOS12              = (iOSVersion.SYS_VERSION_FLOAT >= 12.0 && iOSVersion.SYS_VERSION_FLOAT < 13.0)

}

Wenn Sie die Bildschirmbreite / -höhe unabhängig von der Geräteausrichtung wünschen (nur für die Größenanpassung im Hochformat geeignet), werden Controller im Querformat gestartet:

CGFloat screenWidthInPoints = [UIScreen mainScreen].nativeBounds.size.width/[UIScreen mainScreen].nativeScale;
CGFloat screenHeightInPoints = [UIScreen mainScreen].nativeBounds.size.height/[UIScreen mainScreen].nativeScale;

[UIScreen mainScreen] .nativeBounds <- Aus den Dokumenten -> Das Begrenzungsrechteck des physischen Bildschirms, gemessen in Pixel. Dieses Rechteck basiert auf dem Gerät im Hochformat. Dieser Wert ändert sich nicht, wenn sich das Gerät dreht.

Hier ist ein schneller Weg, um Bildschirmgrößen zu erhalten:

print(screenWidth)
print(screenHeight)

var screenWidth: CGFloat {
    if UIInterfaceOrientationIsPortrait(screenOrientation) {
        return UIScreen.mainScreen().bounds.size.width
    } else {
        return UIScreen.mainScreen().bounds.size.height
    }
}

var screenHeight: CGFloat {
    if UIInterfaceOrientationIsPortrait(screenOrientation) {
        return UIScreen.mainScreen().bounds.size.height
    } else {
        return UIScreen.mainScreen().bounds.size.width
    }
}

var screenOrientation: UIInterfaceOrientation {
    return UIApplication.sharedApplication().statusBarOrientation
}

Diese sind standardmäßig enthalten in:

https://github.com/goktugyil/EZSwiftExtensions

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

schnell 3.0

für die Breite

UIScreen.main.bounds.size.width

Für höhe

UIScreen.main.bounds.size.height

Sie können diese Makros in Ihre PCH-Datei einfügen und mit "SCREEN_WIDTH" an einer beliebigen Stelle im Projekt verwenden.

#define SCREEN_WIDTH                ((([UIApplication sharedApplication].statusBarOrientation == UIInterfaceOrientationPortrait) || ([UIApplication sharedApplication].statusBarOrientation == UIInterfaceOrientationPortraitUpsideDown)) ? [[UIScreen mainScreen] bounds].size.width : [[UIScreen mainScreen] bounds].size.height)

und "SCREEN_HEIGHT"

#define SCREEN_HEIGHT               ((([UIApplication sharedApplication].statusBarOrientation == UIInterfaceOrientationPortrait) || ([UIApplication sharedApplication].statusBarOrientation ==   UIInterfaceOrientationPortraitUpsideDown)) ? [[UIScreen mainScreen] bounds].size.height : [[UIScreen mainScreen] bounds].size.width)

Anwendungsbeispiel:

CGSize calCulateSizze ;
calCulateSizze.width = SCREEN_WIDTH/2-8;
calCulateSizze.height = SCREEN_WIDTH/2-8;