Comment détecter l'iPhone 5 (appareils à écran large)?

Tout d'abord, vous ne devez pas rebuild toutes vos vues pour les adapter à un nouvel écran, ni utiliser des vues différentes pour différentes tailles d'écran.

Utilisez les capacités de redimensionnement automatique d'iOS, afin que vos vues puissent s'ajuster et adapter la taille de l'écran.

Ce n'est pas très dur, lisez de la documentation à ce sujet. Cela vous fera gagner beaucoup de time.

iOS 6 offre également de nouvelles fonctionnalités à ce sujet, mais cela est encore sous NDA pour le moment.
Assurez-vous de lire le journal des modifications de l' API sur le site Web Apple Developer, si vous pouvez y accéder.

Modifier : Comme iOS 6 est maintenant sorti, vérifiez les nouvelles capacités AutoLayout .

Cela dit, si vous avez vraiment besoin de détecter l'iPhone 5, vous pouvez simplement countr sur la taille de l' écran .

[ [ UIScreen mainScreen ] bounds ].size.height 

L'écran de l'iPhone 5 a une hauteur de 568.
Vous pouvez imaginer une macro, pour simplifier tout ceci:

 #define IS_IPHONE_5 ( fabs( ( double )[ [ UIScreen mainScreen ] bounds ].size.height - ( double )568 ) < DBL_EPSILON ) 

L'utilisation de fabs avec l'epsilon est ici pour éviter les erreurs de précision, lors de la comparaison des points flottants, comme indiqué dans les commentaires par H2CO3.

Donc à partir de maintenant vous pouvez l'utiliser dans les instructions if / else standard:

 if( IS_IPHONE_5 ) {} else {} 

Edit – Meilleure détection

Comme indiqué par certaines personnes, cela ne détecte qu'un écran large , pas un iPhone 5 réel.

Les prochaines versions de l'iPod touch auront peut-être aussi un tel écran, nous pouvons donc utiliser un autre jeu de macros.

IS_WIDESCREEN macro d'origine IS_WIDESCREEN :

 #define IS_WIDESCREEN ( fabs( ( double )[ [ UIScreen mainScreen ] bounds ].size.height - ( double )568 ) < DBL_EPSILON ) 

Et ajoutons des macros de détection de model:

 #define IS_IPHONE ( [ [ [ UIDevice currentDevice ] model ] isEqualToSsortingng: @"iPhone" ] ) #define IS_IPOD ( [ [ [ UIDevice currentDevice ] model ] isEqualToSsortingng: @"iPod touch" ] ) 

De cette façon, nous pouvons nous assurer d'avoir un model iPhone ET un écran large, et nous pouvons redéfinir la macro IS_IPHONE_5 :

 #define IS_IPHONE_5 ( IS_IPHONE && IS_WIDESCREEN ) 

Notez également que, comme indiqué par @ LearnCocos2D, ces macros ne fonctionneront pas si l'application n'est pas optimisée pour l'écran de l'iPhone 5 (l'image [email protected] est manquante), car la taille de l'écran sera toujours de 320×480 un cas.

Je ne pense pas que ce soit un problème, car je ne vois pas pourquoi nous voudrions détecter un iPhone 5 dans une application non optimisée.

IMPORTANT – Prise en charge d'iOS 8

Sur iOS 8, la propriété bounds de la class UIScreen reflète désormais l' orientation de l' appareil .
Alors évidemment, le code précédent ne fonctionnera pas hors de la boîte.

Pour résoudre ce problème, vous pouvez simplement utiliser la nouvelle propriété nativeBounds , au lieu de bounds , car elle ne changera pas avec l'orientation, et elle est basée sur un mode portrait-up.
Notez que les dimensions de nativeBounds sont mesurées en pixels, donc pour un iPhone 5, la hauteur sera de 1136 au lieu de 568.

Si vous ciblez également iOS 7 ou une nativeBounds antérieure, assurez-vous d'utiliser la détection des fonctionnalités, car l'appel de nativeBounds avant iOS 8 entraîne le blocage de votre application:

 if( [ [ UIScreen mainScreen ] respondsToSelector: @selector( nativeBounds ) ] ) { /* Detect using nativeBounds - iOS 8 and greater */ } else { /* Detect using bounds - iOS 7 and lower */ } 

Vous pouvez adapter les macros précédentes de la manière suivante:

 #define IS_WIDESCREEN_IOS7 ( fabs( ( double )[ [ UIScreen mainScreen ] bounds ].size.height - ( double )568 ) < DBL_EPSILON ) #define IS_WIDESCREEN_IOS8 ( fabs( ( double )[ [ UIScreen mainScreen ] nativeBounds ].size.height - ( double )1136 ) < DBL_EPSILON ) #define IS_WIDESCREEN ( ( [ [ UIScreen mainScreen ] respondsToSelector: @selector( nativeBounds ) ] ) ? IS_WIDESCREEN_IOS8 : IS_WIDESCREEN_IOS7 ) 

Et évidemment, si vous avez besoin de détecter un iPhone 6 ou 6 Plus, utilisez les tailles d'écran correspondantes.

Note finale

Des commentaires et suggestions ont été incorporés dans ce post.
Merci à tout le monde.

Testé et conçu pour toute combinaison de SDK et OS:

Rapide

Des types d'iPad ajoutés. iPad 2 et iPad mini sont des iPads non rétiniens. Alors que l'iPad Mini 2 et supérieur, iPad 3, 4, iPad Air, Air 2, Air 3 et iPad Pro 9.7 ont la même résolution logique de 1024. iPad Pro a une longueur maximale de 1366. Référence

 import UIKit public enum DisplayType { case unknown case iphone4 case iphone5 case iphone6 case iphone6plus case iPadNonRetina case iPad case iPadProBig static let iphone7 = iphone6 static let iphone7plus = iphone6plus } public final class Display { class var width:CGFloat { return UIScreen.main.bounds.size.width } class var height:CGFloat { return UIScreen.main.bounds.size.height } class var maxLength:CGFloat { return max(width, height) } class var minLength:CGFloat { return min(width, height) } class var zoomed:Bool { return UIScreen.main.nativeScale >= UIScreen.main.scale } class var retina:Bool { return UIScreen.main.scale >= 2.0 } class var phone:Bool { return UIDevice.current.userInterfaceIdiom == .phone } class var pad:Bool { return UIDevice.current.userInterfaceIdiom == .pad } class var carplay:Bool { return UIDevice.current.userInterfaceIdiom == .carPlay } class var tv:Bool { return UIDevice.current.userInterfaceIdiom == .tv } class var typeIsLike:DisplayType { if phone && maxLength < 568 { return .iphone4 } else if phone && maxLength == 568 { return .iphone5 } else if phone && maxLength == 667 { return .iphone6 } else if phone && maxLength == 736 { return .iphone6plus } else if pad && !retina { return .iPadNonRetina } else if pad && retina && maxLength == 1024 { return .iPad } else if pad && maxLength == 1366 { return .iPadProBig } return .unknown } } 

Voir en action https://gist.github.com/hfossli/bc93d924649de881ee2882457f14e346

Remarque: Si par exemple l'iPhone 6 est en mode zoomé, l'interface user est une version agrandie de l'iPhone 5. Ces fonctions ne déterminent pas le type d'appareil, mais le mode d'affichage iPhone 5 est le résultat souhaité dans cet exemple.

Objectif c

 #define IS_IPAD (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) #define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) #define IS_RETINA ([[UIScreen mainScreen] scale] >= 2.0) #define SCREEN_WIDTH ([[UIScreen mainScreen] bounds].size.width) #define SCREEN_HEIGHT ([[UIScreen mainScreen] bounds].size.height) #define SCREEN_MAX_LENGTH (MAX(SCREEN_WIDTH, SCREEN_HEIGHT)) #define SCREEN_MIN_LENGTH (MIN(SCREEN_WIDTH, SCREEN_HEIGHT)) #define IS_ZOOMED (IS_IPHONE && SCREEN_MAX_LENGTH == 736.0) #define IS_IPHONE_4_OR_LESS (IS_IPHONE && SCREEN_MAX_LENGTH < 568.0) #define IS_IPHONE_5 (IS_IPHONE && SCREEN_MAX_LENGTH == 568.0) #define IS_IPHONE_6 (IS_IPHONE && SCREEN_MAX_LENGTH == 667.0) #define IS_IPHONE_6P (IS_IPHONE && SCREEN_MAX_LENGTH == 736.0) 

Utilisation: http://pastie.org/9687735

Remarque: Si par exemple l'iPhone 6 est en mode zoomé, l'interface user est une version agrandie de l'iPhone 5. Ces fonctions ne déterminent pas le type d'appareil, mais le mode d'affichage iPhone 5 est le résultat souhaité dans cet exemple.

Solution vraiment simple

 if(UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) { CGSize result = [[UIScreen mainScreen] bounds].size; if(result.height == 480) { // iPhone Classic } if(result.height == 568) { // iPhone 5 } } 

Nous devons maintenant tenir count des tailles d'écran iPhone 6 et 6Plus. Voici une réponse mise à jour

 if(UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) { //its iPhone. Find out which one? CGSize result = [[UIScreen mainScreen] bounds].size; if(result.height == 480) { // iPhone Classic } else if(result.height == 568) { // iPhone 5 } else if(result.height == 667) { // iPhone 6 } else if(result.height == 736) { // iPhone 6 Plus } } else { //its iPad } 

Quelques informations utiles

 iPhone 6 Plus 736x414 points 2208x1242 pixels 3x scale 1920x1080 physical pixels 401 physical ppi 5.5" iPhone 6 667x375 points 1334x750 pixels 2x scale 1334x750 physical pixels 326 physical ppi 4.7" iPhone 5 568x320 points 1136x640 pixels 2x scale 1136x640 physical pixels 326 physical ppi 4.0" iPhone 4 480x320 points 960x640 pixels 2x scale 960x640 physical pixels 326 physical ppi 3.5" iPhone 3GS 480x320 points 480x320 pixels 1x scale 480x320 physical pixels 163 physical ppi 3.5" 

J'ai pris la liberté de mettre la macro de Macmade dans une fonction C, et de la nommer correctement car elle détecte la disponibilité de l'écran large et PAS nécessairement l'iPhone 5.

La macro ne détecte pas non plus l'exécution sur un iPhone 5 dans le cas où le projet n'inclut pas le [email protected] . Sans la nouvelle image par défaut, l'iPhone 5 indiquera une taille d'écran normale 480×320 (en points). Ainsi, la vérification n'est pas seulement pour la disponibilité du grand écran, mais aussi pour le mode grand écran .

 BOOL isWidescreenEnabled() { return (BOOL)(fabs((double)[UIScreen mainScreen].bounds.size.height - (double)568) < DBL_EPSILON); } 

Voici nos codes, test passé sur ios7 / ios8 pour iphone4, iphone5, ipad, iphone6, iphone6p, peu importe sur les appareils ou simulateur:

 #define IS_IPAD (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) #define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) // iPhone and iPod touch style UI #define IS_IPHONE_5_IOS7 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 568.0f) #define IS_IPHONE_6_IOS7 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 667.0f) #define IS_IPHONE_6P_IOS7 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 736.0f) #define IS_IPHONE_4_AND_OLDER_IOS7 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height < 568.0f) #define IS_IPHONE_5_IOS8 (IS_IPHONE && ([[UIScreen mainScreen] nativeBounds].size.height/[[UIScreen mainScreen] nativeScale]) == 568.0f) #define IS_IPHONE_6_IOS8 (IS_IPHONE && ([[UIScreen mainScreen] nativeBounds].size.height/[[UIScreen mainScreen] nativeScale]) == 667.0f) #define IS_IPHONE_6P_IOS8 (IS_IPHONE && ([[UIScreen mainScreen] nativeBounds].size.height/[[UIScreen mainScreen] nativeScale]) == 736.0f) #define IS_IPHONE_4_AND_OLDER_IOS8 (IS_IPHONE && ([[UIScreen mainScreen] nativeBounds].size.height/[[UIScreen mainScreen] nativeScale]) < 568.0f) #define IS_IPHONE_5 ( ( [ [ UIScreen mainScreen ] respondsToSelector: @selector( nativeBounds ) ] ) ? IS_IPHONE_5_IOS8 : IS_IPHONE_5_IOS7 ) #define IS_IPHONE_6 ( ( [ [ UIScreen mainScreen ] respondsToSelector: @selector( nativeBounds ) ] ) ? IS_IPHONE_6_IOS8 : IS_IPHONE_6_IOS7 ) #define IS_IPHONE_6P ( ( [ [ UIScreen mainScreen ] respondsToSelector: @selector( nativeBounds ) ] ) ? IS_IPHONE_6P_IOS8 : IS_IPHONE_6P_IOS7 ) #define IS_IPHONE_4_AND_OLDER ( ( [ [ UIScreen mainScreen ] respondsToSelector: @selector( nativeBounds ) ] ) ? IS_IPHONE_4_AND_OLDER_IOS8 : IS_IPHONE_4_AND_OLDER_IOS7 ) 

J'ai utilisé la réponse de hfossli et l'ai traduite en swift

 let IS_IPAD = UIDevice.currentDevice().userInterfaceIdiom == .Pad let IS_IPHONE = UIDevice.currentDevice().userInterfaceIdiom == .Phone let IS_RETINA = UIScreen.mainScreen().scale >= 2.0 let SCREEN_WIDTH = UIScreen.mainScreen().bounds.size.width let SCREEN_HEIGHT = UIScreen.mainScreen().bounds.size.height let SCREEN_MAX_LENGTH = max(SCREEN_WIDTH, SCREEN_HEIGHT) let SCREEN_MIN_LENGTH = min(SCREEN_WIDTH, SCREEN_HEIGHT) let IS_IPHONE_4_OR_LESS = (IS_IPHONE && SCREEN_MAX_LENGTH < 568.0) let IS_IPHONE_5 = (IS_IPHONE && SCREEN_MAX_LENGTH == 568.0) let IS_IPHONE_6 = (IS_IPHONE && SCREEN_MAX_LENGTH == 667.0) let IS_IPHONE_6P = (IS_IPHONE && SCREEN_MAX_LENGTH == 736.0) 

c'est la macro pour mon projet cocos2d. devrait être le même pour les autres applications.

 #define WIDTH_IPAD 1024 #define WIDTH_IPHONE_5 568 #define WIDTH_IPHONE_4 480 #define HEIGHT_IPAD 768 #define HEIGHT_IPHONE 320 #define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) #define IS_IPAD (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) //width is height! #define IS_IPHONE_5 ( [ [ UIScreen mainScreen ] bounds ].size.height == WIDTH_IPHONE_5 ) #define IS_IPHONE_4 ( [ [ UIScreen mainScreen ] bounds ].size.height == WIDTH_IPHONE_4 ) #define cp_ph4(__X__, __Y__) ccp(cx_ph4(__X__), cy_ph4(__Y__)) #define cx_ph4(__X__) (IS_IPAD ? (__X__ * WIDTH_IPAD / WIDTH_IPHONE_4) : (IS_IPHONE_5 ? (__X__ * WIDTH_IPHONE_5 / WIDTH_IPHONE_4) : (__X__))) #define cy_ph4(__Y__) (IS_IPAD ? (__Y__ * HEIGHT_IPAD / HEIGHT_IPHONE) : (__Y__)) #define cp_pad(__X__, __Y__) ccp(cx_pad(__X__), cy_pad(__Y__)) #define cx_pad(__X__) (IS_IPAD ? (__X__) : (IS_IPHONE_5 ? (__X__ * WIDTH_IPHONE_5 / WIDTH_IPAD) : (__X__ * WIDTH_IPHONE_4 / WIDTH_IPAD))) #define cy_pad(__Y__) (IS_IPAD ? (__Y__) : (__Y__ * HEIGHT_IPHONE / HEIGHT_IPAD)) 

 if ((int)[[UIScreen mainScreen] bounds].size.height == 568) { // This is iPhone 5 screen } else { // This is iPhone 4 screen } 

Dans Swift, iOS 8+ projet j'aime faire une extension sur UIScreen , comme:

 extension UIScreen { var isPhone4: Bool { return self.nativeBounds.size.height == 960; } var isPhone5: Bool { return self.nativeBounds.size.height == 1136; } var isPhone6: Bool { return self.nativeBounds.size.height == 1334; } var isPhone6Plus: Bool { return self.nativeBounds.size.height == 2208; } } 

(NOTE: nativeBounds est en pixels).

Et puis le code sera comme:

 if UIScreen.mainScreen().isPhone4 { // do smth on the smallest screen } 

Ainsi, le code indique clairement qu'il s'agit d'une vérification pour l'écran principal, pas pour le model de l'appareil.

Empruntant à la réponse de Samrat Mazumdar, voici une courte méthode qui estime la taille de l'écran de l'appareil. Il fonctionne avec les derniers périphériques, mais peut échouer sur les futurs (comme toutes les methods de deviner). Il sera également confus si l'appareil est en miroir (renvoie la taille de l'écran de l'appareil, pas la taille de l'écran en miroir)

 #define SCREEN_SIZE_IPHONE_CLASSIC 3.5 #define SCREEN_SIZE_IPHONE_TALL 4.0 #define SCREEN_SIZE_IPAD_CLASSIC 9.7 + (CGFloat)screenPhysicalSize { if(UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) { CGSize result = [[UIScreen mainScreen] bounds].size; if (result.height < 500) return SCREEN_SIZE_IPHONE_CLASSIC; // iPhone 4S / 4th Gen iPod Touch or earlier else return SCREEN_SIZE_IPHONE_TALL; // iPhone 5 } else { return SCREEN_SIZE_IPAD_CLASSIC; // iPad } } 

Je pense qu'il devrait être bon si cette macro fonctionnera dans le dispositif et le simulateur, ci-dessous sont la solution.

 #define IS_WIDESCREEN (fabs((double)[[UIScreen mainScreen]bounds].size.height - (double)568) < DBL_EPSILON) #define IS_IPHONE (([[[UIDevice currentDevice] model] isEqualToSsortingng:@"iPhone"]) || ([[[UIDevice currentDevice] model] isEqualToSsortingng: @"iPhone Simulator"])) #define IS_IPOD ([[[UIDevice currentDevice]model] isEqualToSsortingng:@"iPod touch"]) #define IS_IPHONE_5 ((IS_IPHONE || IS_IPOD) && IS_WIDESCREEN) 

J'ai trouvé que les réponses ne include pas de cas particulier pour les simulateurs.

 #define IS_WIDESCREEN ( [ [ UIScreen mainScreen ] bounds ].size.height == 568 ) #define IS_IPHONE ([[ [ UIDevice currentDevice ] model ] rangeOfSsortingng:@"iPhone"].location != NSNotFound) #define IS_IPAD ([[ [ UIDevice currentDevice ] model ] rangeOfSsortingng:@"iPad"].location != NSNotFound) #define IS_IPHONE_5 ( IS_IPHONE && IS_WIDESCREEN ) 

 +(BOOL)isDeviceiPhone5 { BOOL iPhone5 = FALSE; CGRect screenBounds = [[UIScreen mainScreen] bounds]; if (screenBounds.size.height == 568) { // code for 4-inch screen iPhone5 = TRUE; } else { iPhone5 = FALSE; // code for 3.5-inch screen } return iPhone5; } 

 CGFloat height = [UIScreen mainScreen].bounds.size.height; NSLog(@"screen soze is %f",height); if (height>550) { // 4" screen-do some thing } else if (height<500) { // 3.5 " screen- do some thing } 

S'appuyer sur la taille est faux à tant de niveaux. Que diriez-vous de requestr au système?

 - (NSSsortingng *) getDeviceModel { struct utsname systemInfo; uname(&systemInfo); return [NSSsortingng ssortingngWithCSsortingng:systemInfo.machine encoding:NSUTF8SsortingngEncoding]; } 

Tiré de Meilleur moyen de détecter le type de matériel, iPhone4 ou iPhone5? , réponse edzio27.

De cette façon, vous pouvez détecter la famille de périphériques.

  #import <sys/utsname.h> NSSsortingng* deviceName() { struct utsname systemInformation; uname(&systemInformation); NSSsortingng *result = [NSSsortingng ssortingngWithCSsortingng:systemInformation.machine encoding:NSUTF8SsortingngEncoding]; return result; } #define isIPhone5 [deviceName() rangeOfSsortingng:@"iPhone5,"].location != NSNotFound #define isIPhone5S [deviceName() rangeOfSsortingng:@"iPhone6,"].location != NSNotFound 

Si le projet est créé à l'aide de Xcode 6, utilisez le code mentionné ci-dessous pour détecter les périphériques.

 printf("\nDetected Resolution : %dx %d\n\n",(int)[[UIScreen mainScreen] nativeBounds].size.width,(int)[[UIScreen mainScreen] nativeBounds].size.height); if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone){ if ([[UIScreen mainScreen] respondsToSelector: @selector(scale)]) { if([[UIScreen mainScreen] nativeBounds].size.height == 960 || [[UIScreen mainScreen] nativeBounds].size.height == 480){ printf("Device Type : iPhone 4,4s "); }else if([[UIScreen mainScreen] nativeBounds].size.height == 1136){ printf("Device Type : iPhone 5,5S/iPod 5 "); }else if([[UIScreen mainScreen] nativeBounds].size.height == 1334){ printf("Device Type : iPhone 6 "); }else if([[UIScreen mainScreen] nativeBounds].size.height == 2208){ printf("Device Type : iPhone 6+ "); } } }else{ printf("Device Type : iPad"); } 

Si le projet a été créé dans Xcode 5 et ouvert dans Xcode 6, utilisez le code ci-dessous pour détecter les périphériques (ce code fonctionne si aucune image de lancement pour iPhone 6,6+ n'est affectée)

 printf("\nDetected Resolution : %dx %d\n\n",(int)[[UIScreen mainScreen] nativeBounds].size.width,(int)[[UIScreen mainScreen] nativeBounds].size.height); if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone){ if ([[UIScreen mainScreen] respondsToSelector: @selector(scale)]) { if([[UIScreen mainScreen] nativeBounds].size.height == 960 || [[UIScreen mainScreen] nativeBounds].size.height == 480){ printf("Device Type : iPhone 4,4s"); appType=1; }else if([[UIScreen mainScreen] nativeBounds].size.height == 1136 || [[UIScreen mainScreen] nativeBounds].size.height == 1704){ printf("Device Type : iPhone 5,5S,6,6S/iPod 5 "); appType=3; } } }else{ printf("Device Type : iPad"); appType=2; } 

Si vous utilisez toujours Xcode 5, utilisez le code suivant pour détecter les périphériques (les iPhone 6 et 6+ ne seront pas détectés)

 printf("\nDetected Resolution : %dx %d\n\n",(int)[[UIScreen mainScreen] bounds].size.width,(int)[[UIScreen mainScreen] bounds].size.height); if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone){ if ([[UIScreen mainScreen] respondsToSelector: @selector(scale)]) { CGSize result = [[UIScreen mainScreen] bounds].size; CGFloat scale = [UIScreen mainScreen].scale; result = CGSizeMake(result.width * scale, result.height * scale); if(result.height == 960 || result.height == 480){ printf("Device Type : iPhone 4,4S "); }else if(result.height == 1136){ printf("Device Type : iPhone 5s/iPod 5"); } } }else{ printf("Device Type : iPad"); } 

1. Ajouter un 'Nouveau file Swift' -> AppDelegateEx.swift

2. append une extension à AppDelegate

    import UIKit extension AppDelegate { class func isIPhone5 () -> Bool{ return max(UIScreen.mainScreen().bounds.width, UIScreen.mainScreen().bounds.height) == 568.0 } class func isIPhone6 () -> Bool { return max(UIScreen.mainScreen().bounds.width, UIScreen.mainScreen().bounds.height) == 667.0 } class func isIPhone6Plus () -> Bool { return max(UIScreen.mainScreen().bounds.width, UIScreen.mainScreen().bounds.height) == 736.0 } } 

3. usage:

     if AppDelegate.isIPhone5() { collectionViewTopConstraint.constant = 2 }else if AppDelegate.isIPhone6() { collectionViewTopConstraint.constant = 20 } 

Cela a été répondu une centaine de fois mais cette solution a fonctionné le mieux pour moi. C'est une fonction d'aide simple et ne nécessite pas d'extension d'une class système.

Swift 3 Helper:

 func phoneSizeInInches(defaultValue: Float = 4.7) -> Float { switch (UIScreen.main.nativeBounds.size.height) { case 960, 480: return 3.5 case 1136: return 4 case 1334: return 4.7 case 2208: return 5.5 default: return defaultValue } } 

C'est parce qu'il est facile de mémoriser les tailles de pouce d'un téléphone, comme, "5,5 pouces" ou "4,7 pouces" appareil, mais difficile de se callbacker les tailles de pixels exactes.

 if phoneSizeInInches() == 4 { //do something with only 4 inch iPhones } 

Cela vous donne également l'opportunité de faire quelque chose comme ceci:

 if phoneSizeInInches() < 5.5 { //do something all iPhones smaller than the plus } 

La valeur "defaultValue" garantit que votre code récupérera toujours une taille sûre si Apple publie une nouvelle taille de périphérique et que vous n'avez pas encore mis à jour votre application.

 if phoneSizeInInches(defaultValue: 4.7) == 4 { //if a new iPhone size is introduced, your code will default to behaving like a 4.7 inch iPhone } 

Notez que cela est spécifique pour les applications téléphoniques, il faudra quelques changements pour les universels.

Dans Swift 3, vous pouvez utiliser ma class simple KRDeviceType.

https://github.com/ulian-onua/KRDeviceType

Il est bien documenté et supporte les opérateurs ==,> =, <=.

Par exemple pour détecter si l'appareil a des limites de l'iPhone 6 / 6s / 7, vous pouvez simplement utiliser la comparaison suivante:

 if KRDeviceType() == .iPhone6 { // Perform appropiate operations } 

Pour détecter si l'appareil a des limites de l'iPhone 5 / 5S / SE ou plus tôt (iPhone 4s), vous pouvez utiliser la comparaison suivante:

 if KRDeviceType() <= .iPhone5 { //iPhone 5/5s/SE of iPhone 4s // Perform appropiate operations (for example, set up constraints for those old devices) } 

utilisez le code suivant:

 CGFloat screenScale = [[UIScreen mainScreen] scale]; CGRect screenBounds = [[UIScreen mainScreen] bounds]; CGSize screenSize = CGSizeMake(screenBounds.size.width * screenScale, screenBounds.size.height * screenScale); if (screenSize.height==1136.000000) { // Here iPhone 5 View // Eg: Nextview~iPhone5.Xib } else { // Previous Phones // Eg : Nextview.xib } 

Voici le bon test de l'appareil, sans dépendre de l'orientation

 - (BOOL)isIPhone5 { CGSize size = [[UIScreen mainScreen] bounds].size; if (MIN(size.width,size.height) == 320 && MAX(size.width,size.height == 568)) { return YES; } return NO; } 

Utilisé pour détecter les appareils iPhone et iPad de tous les versons.

 #define IS_IPAD (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) #define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) #define IS_IPHONE_5 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 568.0) #define IS_IPHONE_6 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 667.0) #define IS_IPHONE_6_PLUS (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 736.0) #define IS_RETINA ([[UIScreen mainScreen] scale] == 2.0)