Comment obtenir la largeur et la hauteur de l'écran dans iOS?
Comment obtenir les dimensions de l'écran sous iOS?
Actuellement, j'utilise:
lCurrentWidth = self.view.frame.size.width;
lCurrentHeight = self.view.frame.size.height;
dans viewWillAppear: et willAnimateRotationToInterfaceOrientation:duration:
La première fois que je reçois toute la taille de l'écran. La deuxième fois, je reçois l’écran moins la barre de navigation.
Comment obtenir les dimensions de l'écran sous iOS?
Le problème avec le code que vous avez posté est que vous comptez sur la taille de la vue pour qu'elle corresponde à celle de l'écran, et comme vous l'avez vu, ce n'est pas toujours le cas. Si vous avez besoin de la taille de l'écran, vous devriez regarder l'objet qui représente l'écran lui-même, comme ceci:
CGRect screenRect = [[UIScreen mainScreen] bounds];
CGFloat screenWidth = screenRect.size.width;
CGFloat screenHeight = screenRect.size.height;
Mise à jour pour une vue partagée: Dans les commentaires, Dmitry a demandé:
Comment puis-je obtenir la taille de l'écran dans la vue fractionnée?
Le code indiqué ci-dessus indique la taille de l'écran, même en mode d'écran divisé. Lorsque vous utilisez le mode d'écran partagé, la fenêtre de votre application change. Si le code ci-dessus ne vous donne pas les informations que vous attendez, alors, comme pour le PO, vous vous trouvez face au mauvais objet. Dans ce cas, vous devriez regarder la fenêtre au lieu de l’écran, comme ceci:
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
Attention, [UIScreen mainScreen] contient également une barre d'état. Si vous souhaitez récupérer le cadre de votre application (à l'exception de la barre d'état), vous devez utiliser
+ (CGFloat) window_height {
return [UIScreen mainScreen].applicationFrame.size.height;
}
+ (CGFloat) window_width {
return [UIScreen mainScreen].applicationFrame.size.width;
}
J'ai traduit certaines des réponses Objective-C ci-dessus en code Swift. Chaque traduction est traitée avec une référence à la réponse originale.
Réponse principale
let screen = UIScreen.main.bounds
let screenWidth = screen.size.width
let screenHeight = screen.size.height
Réponse de fonction simple
func windowHeight() -> CGFloat {
return UIScreen.mainScreen().applicationFrame.size.height
}
func windowWidth() -> CGFloat {
return UIScreen.mainScreen().applicationFrame.size.width
}
Réponse d'orientation du périphérique
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
}
Réponse du journal
let screenWidth = UIScreen.mainScreen().bounds.size.width
let screenHeight = UIScreen.mainScreen().bounds.size.height
println("width: \(screenWidth)")
println("height: \(screenHeight)")
J'ai déjà utilisé ces méthodes de commodité:
- (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;
}
Je me rends compte qu'il s'agit d'un ancien post, mais parfois je trouve utile de #définir des constantes comme celles-ci afin de ne pas m'inquiéter pour ça:
#define DEVICE_SIZE [[[[UIApplication sharedApplication] keyWindow] rootViewController].view convertRect:[[UIScreen mainScreen] bounds] fromView:nil].size
La constante ci-dessus doit renvoyer la taille correcte, quelle que soit l'orientation du périphérique. Obtenir les dimensions est aussi simple que:
lCurrentWidth = DEVICE_SIZE.width;
lCurrentHeight = DEVICE_SIZE.height;
Il est très facile d’obtenir la taille de votre appareil ainsi que tenez compte de l’orientation:
// 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];
Nous devons également tenir compte de l'orientation de l'appareil:
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);
Ici, j'ai mis à jour pour Swift 3
applicationFrame obsolète pour iOS 9
Dans Swift trois, ils ont supprimé () et ont modifié peu la convention de dénomination. Vous pouvez vous référer ici Lien
func windowHeight() -> CGFloat {
return UIScreen.main.bounds.size.height
}
func windowWidth() -> CGFloat {
return UIScreen.main.bounds.size.width
}
tilisez ces Structs pour connaître des informations utiles sur le périphérique actuel dans Swift 3.
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)
}
Si vous souhaitez une largeur/hauteur d'écran indépendamment de l'orientation du périphérique (idéal pour le dimensionnement des contrôleurs de vue en mode portrait lancés à partir de l'orientation paysage):
CGFloat screenWidthInPoints = [UIScreen mainScreen].nativeBounds.size.width/[UIScreen mainScreen].nativeScale;
CGFloat screenHeightInPoints = [UIScreen mainScreen].nativeBounds.size.height/[UIScreen mainScreen].nativeScale;
[UIScreen mainScreen] .nativeBounds <- Depuis la documentation -> Le rectangle de délimitation de l'écran physique, mesuré en pixels. Ce rectangle est basé sur le périphérique dans une orientation portrait. Cette valeur ne change pas lorsque l'appareil est en rotation.
Voici un moyen Swift d'obtenir les tailles d'écran:
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
}
Ceux-ci sont inclus en tant que fonction standard dans:
CGFloat width = [[UIScreen mainScreen] bounds].size.width; CGFloat height = [[UIScreen mainScreen]bounds ].size.height;
La réponse moderne:
si votre application prend en charge la vue partagée sur iPad, ce problème devient un peu compliqué. Vous avez besoin de la taille de la fenêtre, pas de celle de l'écran, qui peut contenir 2 applications. La taille de la fenêtre peut également varier lors de l'exécution.
Utilisez la taille de la fenêtre principale de l'application:
UIApplication.shared.delegate?.window??.bounds.size ?? .zero
Remarque: La méthode ci-dessus peut obtenir une valeur incorrecte avant que la fenêtre ne devienne une fenêtre clé au démarrage. si vous avez seulement besoin de largeur, la méthode ci-dessous est très recommandé:
UIApplication.shared.statusBarFrame.width
L'ancienne solution utilisant UIScreen.main.bounds renverra les limites du périphérique. Si votre application fonctionne en mode d'affichage fractionné, les dimensions sont incorrectes.
self.view.window dans la réponse la plus chaude peut avoir une taille incorrecte lorsque l'application contient 2 fenêtres ou plus et que la fenêtre est de petite taille.
Swift 3.0
pour la largeur
UIScreen.main.bounds.size.width
pour la hauteur
UIScreen.main.bounds.size.height