Come ottenere la larghezza e l'altezza dello schermo in iOS?

Come si possono ottenere le dimensioni dello schermo in iOS?

Attualmente utilizzo:

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

in viewWillAppear:ewillAnimateRotationToInterfaceOrientation:duration:

La prima volta che visualizzo l'intera dimensione dello schermo. La seconda volta ottengo lo schermo meno la barra di navigazione.

Come si possono ottenere le dimensioni dello schermo in iOS?

Il problema con il codice che hai pubblicato è che stai contando sulla dimensione della vista per corrispondere a quella dello schermo, e come hai visto non è sempre il caso. Se hai bisogno delle dimensioni dello schermo, dovresti guardare l'oggetto che rappresenta lo schermo stesso, in questo modo:

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

Aggiornamento per vista divisa: nei commenti, Dmitry ha chiesto:

Come posso ottenere le dimensioni dello schermo nella vista divisa?

Il codice sopra riportato riporta le dimensioni dello schermo, anche in modalità schermo diviso. Quando si utilizza la modalità schermo diviso, la finestra dell'app cambia. Se il codice sopra non ti dà le informazioni che ti aspetti, quindi come l'OP, stai guardando l'oggetto sbagliato. In questo caso, tuttavia, dovresti guardare la finestra anziché lo schermo, in questo modo:

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

Rapido 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

Attento, [UIScreen mainScreen] contiene anche la barra di stato, se si desidera recuperare il frame per l'applicazione (esclusa la barra di stato) è necessario utilizzare

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

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

Ho tradotto alcune delle precedenti risposte Objective-C in codice Swift. Ogni traduzione è seguita da un riferimento alla risposta originale.

Risposta principale

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

Risposta semplice funzione

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

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

Risposta orientamento dispositivo

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
}

Registro risposta

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

Ho usato questi metodi di convenienza prima:

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

Mi rendo conto che questo è un vecchio post, ma a volte trovo utile #define costanti come queste, quindi non devo preoccuparmene:

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

La costante di cui sopra dovrebbe restituire la dimensione corretta indipendentemente dall'orientamento del dispositivo. Quindi ottenere le dimensioni è semplice come:

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

È molto, molto semplice ottenere le dimensioni del dispositivo e tenere conto dell'orientamento:

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

Dobbiamo considerare anche l'orientamento del dispositivo:

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

Qui ho aggiornato per Swift 3

applicationFrame deprecato da iOS 9

In tre rapidi hanno rimosso () e hanno modificato alcune convenzioni di denominazione, è possibile fare riferimento qui Link

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

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

La risposta moderna:

se la tua app supporta la visualizzazione divisa su iPad, questo problema diventa un po 'complicato. Sono necessarie le dimensioni della finestra, non quelle dello schermo, che possono contenere 2 app. Le dimensioni della finestra possono anche variare durante l'esecuzione.

Usa le dimensioni della finestra principale dell'app:

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

Nota: il metodo sopra riportato potrebbe avere un valore errato prima che la finestra diventi una finestra chiave all'avvio. se hai solo bisogno di larghezza, il metodo seguente è molto raccomandato :

UIApplication.shared.statusBarFrame.width

La vecchia soluzione che utilizza UIScreen.main.boundsrestituirà i limiti del dispositivo. Se la tua app funziona in modalità di visualizzazione divisa, ottiene dimensioni errate.

self.view.window nella risposta più calda potrebbe avere dimensioni errate quando l'app contiene 2 o più finestre e la finestra ha dimensioni ridotte.

Utilizzali Structsper conoscere informazioni utili sul dispositivo corrente in Swift 3.0

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)

}

Se si desidera la larghezza / altezza dello schermo indipendentemente dall'orientamento del dispositivo (buono per dimensionare solo i controller di visualizzazione verticale lanciati da orientamenti orizzontali):

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

[UIScreen mainScreen] .nativeBounds <- Dai documenti -> Il rettangolo di delimitazione dello schermo fisico, misurato in pixel. Questo rettangolo si basa sul dispositivo con orientamento verticale. Questo valore non cambia quando il dispositivo ruota.

Ecco un modo rapido per ottenere le dimensioni dello schermo:

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
}

Questi sono inclusi come funzione standard in:

https://github.com/goktugyil/EZSwiftExtensions

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

veloce 3.0

per larghezza

UIScreen.main.bounds.size.width

per altezza

UIScreen.main.bounds.size.height

Puoi posizionare queste macro nel tuo file pch e utilizzarle ovunque nel progetto usando "SCREEN_WIDTH"

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

e "SCREEN_HEIGHT"

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

Esempio di utilizzo:

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