Détection de tailles d'écran iPhone 6/6 + en points
Compte tenu de la nouvelle taille annoncée de l'iPhone 6 de l'écran :
iPhone 6: 1334h * 750w @2x (in points: 667h * 375w)
iPhone 6+: 1920 * 1080 @3x (in points: 640h * 360w)
Je me demandais s'il existait un code qui me permettait de détecter la taille de l'écran du périphérique de l'utilisateur afin de pouvoir ajuster et dimensionner UIImages et d'autres documents en conséquence avec le périphérique de l'utilisateur.
Jusqu'à présent, j'ai utilisé les éléments suivants:
- (NSString *) platform{
size_t size;
sysctlbyname("hw.machine", NULL, &size, NULL, 0);
char *machine = malloc(size);
sysctlbyname("hw.machine", machine, &size, NULL, 0);
NSString *platform = [NSString stringWithUTF8String:machine];
free(machine);
return platform;
}
- (NSString *) platformString{
NSString *platform = [self platform];
if ([platform isEqualToString:@"iPhone1,1"]) return @"iPhone 1G";
if ([platform isEqualToString:@"iPhone1,2"]) return @"iPhone 3G";
if ([platform isEqualToString:@"iPhone2,1"]) return @"iPhone 3GS";
if ([platform isEqualToString:@"iPhone3,1"]) return @"iPhone 4";
if ([platform isEqualToString:@"iPhone3,3"]) return @"Verizon iPhone 4";
if ([platform isEqualToString:@"iPhone4,1"]) return @"iPhone 4S";
if ([platform isEqualToString:@"iPhone5,1"]) return @"iPhone 5 (GSM)";
if ([platform isEqualToString:@"iPhone5,2"]) return @"iPhone 5 (GSM+CDMA)";
if ([platform isEqualToString:@"iPhone5,3"]) return @"iPhone 5c (GSM)";
if ([platform isEqualToString:@"iPhone5,4"]) return @"iPhone 5c (GSM+CDMA)";
if ([platform isEqualToString:@"iPhone6,1"]) return @"iPhone 5s (GSM)";
if ([platform isEqualToString:@"iPhone6,2"]) return @"iPhone 5s (GSM+CDMA)";
if ([platform isEqualToString:@"iPod1,1"]) return @"iPod Touch 1G";
if ([platform isEqualToString:@"iPod2,1"]) return @"iPod Touch 2G";
if ([platform isEqualToString:@"iPod3,1"]) return @"iPod Touch 3G";
if ([platform isEqualToString:@"iPod4,1"]) return @"iPod Touch 4G";
if ([platform isEqualToString:@"iPod5,1"]) return @"iPod Touch 5G";
if ([platform isEqualToString:@"iPad1,1"]) return @"iPad";
if ([platform isEqualToString:@"iPad2,1"]) return @"iPad 2 (WiFi)";
if ([platform isEqualToString:@"iPad2,2"]) return @"iPad 2 (GSM)";
if ([platform isEqualToString:@"iPad2,3"]) return @"iPad 2 (CDMA)";
if ([platform isEqualToString:@"iPad2,4"]) return @"iPad 2 (WiFi)";
if ([platform isEqualToString:@"iPad2,5"]) return @"iPad Mini (WiFi)";
if ([platform isEqualToString:@"iPad2,6"]) return @"iPad Mini (GSM)";
if ([platform isEqualToString:@"iPad2,7"]) return @"iPad Mini (GSM+CDMA)";
if ([platform isEqualToString:@"iPad3,1"]) return @"iPad 3 (WiFi)";
if ([platform isEqualToString:@"iPad3,2"]) return @"iPad 3 (GSM+CDMA)";
if ([platform isEqualToString:@"iPad3,3"]) return @"iPad 3 (GSM)";
if ([platform isEqualToString:@"iPad3,4"]) return @"iPad 4 (WiFi)";
if ([platform isEqualToString:@"iPad3,5"]) return @"iPad 4 (GSM)";
if ([platform isEqualToString:@"iPad3,6"]) return @"iPad 4 (GSM+CDMA)";
if ([platform isEqualToString:@"iPad4,1"]) return @"iPad Air (WiFi)";
if ([platform isEqualToString:@"iPad4,2"]) return @"iPad Air (Cellular)";
if ([platform isEqualToString:@"iPad4,4"]) return @"iPad mini 2G (WiFi)";
if ([platform isEqualToString:@"iPad4,5"]) return @"iPad mini 2G (Cellular)";
if ([platform isEqualToString:@"i386"]) return @"Simulator";
if ([platform isEqualToString:@"x86_64"]) return @"Simulator";
return platform;
}
En tant que tel, devrais-je supposer que iPhone7,1 et iPhone7,2 sont l'iPhone 6, alors que iPhone7,3 et iPhone7.4 sont les avantages? Si quelqu'un a un moyen plus concret de dire que ce serait génial, merci.!
Le premier écran sera l'écran de l'appareil. Notez que les images de lancement des nouveaux téléphones doivent être ajoutées avant, sinon l'application est exécutée en mode zoomé pour les anciennes applications: Voici le code que j'ai utilisé pour vérifier cela. Remarque: cela ne fonctionne qu'avec la version iOS 8 et supérieure :
UIScreen *mainScreen = [UIScreen mainScreen];
NSLog(@"Screen bounds: %@, Screen resolution: %@, scale: %f, nativeScale: %f",
NSStringFromCGRect(mainScreen.bounds), mainScreen.coordinateSpace, mainScreen.scale, mainScreen.nativeScale);
Code de détection de l'iPhone 6 Plus:
#define IS_PAD (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad)
#define IS_PHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone)
-(BOOL)iPhone6PlusDevice{
if (!IS_PHONE) return NO;
if ([UIScreen mainScreen].scale > 2.9) return YES; // Scale is only 3 when not in scaled mode for iPhone 6 Plus
return NO;
}
ou
-(BOOL) iPhone6PlusUnZoomed{
if ([self iPhone6PlusDevice]){
if ([UIScreen mainScreen].bounds.size.height > 720.0) return YES; // Height is 736, but 667 when zoomed.
}
return NO;
}
Remarque: si vous recherchez l'iPhone 6 Plus, pour ajuster l'interface utilisateur, ne vous fiez pas à .nativeScale, car le simulateur et le périphérique réel donnent des résultats différents. En raison du commentaire ci-dessous. Scale est une CGFloat et, par conséquent, le code ne doit pas vérifier l’égalité, car certaines valeurs flottantes peuvent ne jamais être égales.
Après avoir ajouté Écran de lancement , vous pouvez utiliser les nouvelles tailles d’iPhone, sinon votre application sera toujours mise à l’échelle.
Mis à jour pour les nouveaux iPhones X ????, X ???? et X ???? Max
Taille pour iPhone X ???? Max avec @ 3x mise à l'échelle (nom Apple: écran Super Retina HD 6.5 "), espace de coordonnées: 414 x 896 points et 1242 x 2688 pixels, 458 ppp , la taille physique du périphérique est de 3,05 x 6,20 po ou 77,4 x 157,5 mm.
let screen = UIScreen.main
print("Screen bounds: \(screen.bounds), Screen resolution: \(screen.nativeBounds), scale: \(screen.scale)")
//iPhone X???? Max Screen bounds: (0.0, 0.0, 414.0, 896.0), Screen resolution: (0.0, 0.0, 1242.0, 2688.0), scale: 3.0
Taille pour iPhone X ???? avec @ 2x mise à l'échelle (nom Apple: Super Retina HD 6.1 "display ), espace de coordonnées: 414 x 896 points et 828 x 1792 pixels, 326 ppp, la taille physique du périphérique est de 2,98 x 5,94 pouces ou 75,7 x 150,9 mm.
let screen = UIScreen.main
print("Screen bounds: \(screen.bounds), Screen resolution: \(screen.nativeBounds), scale: \(screen.scale)")
//iPhone X???? Screen bounds: (0.0, 0.0, 414.0, 896.0), Screen resolution: (0.0, 0.0, 828.0, 1792.0), scale: 2.0
Taille pour iPhone X ???? et iPhone X avec @ 3 x mise à l’échelle (nom Apple: Super Retina HD 5.8 "), espace de coordonnées: 375 x 812 points et 1125 x 2436 pixels, 458 ppp, la taille physique du périphérique est de 2,79 x 5,65 pouces ou 70,9 x 143,6 mm.
let screen = UIScreen.main
print("Screen bounds: \(screen.bounds), Screen resolution: \(screen.nativeBounds), scale: \(screen.scale)")
//iPhone X???? and X Screen bounds: (0.0, 0.0, 375.0, 812.0), Screen resolution: (0.0, 0.0, 1125.0, 2436.0), scale: 3.0
Taille pour iPhone 8, 7, 6 Plus et iPhone 8, 7, 6S Plus avec mise à l'échelle @ 3x (nom Apple: Retina HD 5.5 ), Espace de coordonnées: 414 x 736 points et 1242 x 2208 pixels, 401 ppp, la taille physique de l'écran est de 2,7 x 4,8 pouces ou 68 x 122 mm :
Screen bounds: {{0, 0}, {414, 736}}, Screen resolution: <UIScreen: 0x7f97fad330b0; bounds = {{0, 0}, {414, 736}};
mode = <UIScreenMode: 0x7f97fae1ce00; size = 1242.000000 x 2208.000000>>, scale: 3.000000, nativeScale: 3.000000
Taille pour iPhone 6 et iPhone 6S avec mise à l'échelle @ 2x (nom Apple: Retina HD 4.7 ), espace de coordonnées: 375 x 667 points et 750 x 1334 pixels, 326 ppp, la taille physique de l'écran est de 2,3 x 4,1 pouces ou 58 x 104 mm :
Screen bounds: {{0, 0}, {375, 667}}, Screen resolution: <UIScreen: 0x7fa01b5182d0; bounds = {{0, 0}, {375, 667}};
mode = <UIScreenMode: 0x7fa01b711760; size = 750.000000 x 1334.000000>>, scale: 2.000000, nativeScale: 2.000000
Et iPhone 5 à des fins de comparaison: 640 x 1136, iPhone 4 640 x 960.
Remarque: Téléchargez LaunchImages, sinon l'application s'exécutera à l'échelle et ne montrera pas une mise à l'échelle ou une taille d'écran correcte.
Si vous préférez les macros, voici celles que vous pouvez utiliser pour différencier les modèles d’iPhone. Celles-ci sont basées sur les valeurs en points.
#define IS_IPHONE_4 (fabs((double)[[UIScreen mainScreen]bounds].size.height - (double)480) < DBL_EPSILON)
#define IS_IPHONE_5 (fabs((double)[[UIScreen mainScreen]bounds].size.height - (double)568) < DBL_EPSILON)
#define IS_IPHONE_6 (fabs((double)[[UIScreen mainScreen]bounds].size.height - (double)667) < DBL_EPSILON)
#define IS_IPHONE_6_PLUS (fabs((double)[[UIScreen mainScreen]bounds].size.height - (double)736) < DBL_EPSILON)
J'utilise le code suivant pour déterminer quel périphérique est en marche
if( UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone ){
CGFloat screenHeight = [UIScreen mainScreen].bounds.size.height;
CGFloat screenWidth = [UIScreen mainScreen].bounds.size.width;
if( screenHeight < screenWidth ){
screenHeight = screenWidth;
}
if( screenHeight > 480 && screenHeight < 667 ){
NSLog(@"iPhone 5/5s");
} else if ( screenHeight > 480 && screenHeight < 736 ){
NSLog(@"iPhone 6");
} else if ( screenHeight > 480 ){
NSLog(@"iPhone 6 Plus");
} else {
NSLog(@"iPhone 4/4s");
}
}
(Cela ne fonctionne que lorsque l'iPhone 6/6 Plus est activé en ajoutant les écrans de démarrage appropriés)
Consultez la liste mise à jour sur wiki , là, j’ai eu 7,2 pour iPhone 6 et 7,1 pour iPhone 6 plus.
Sur le périphérique physique, les limites de l'écran principal de l'iPhone 6 Plus sont 2208x1242 et nativeBounds est de 1920x1080. Il y a une mise à l'échelle matérielle impliquée pour redimensionner l'affichage physique.
Sur le simulateur, les limites de l'écran principal de l'iPhone 6 Plus et celles de NativeBounds sont toutes les deux de 2208x1242.
En d'autres termes ... Les vidéos, OpenGL et d'autres éléments basés sur CALayers qui traitent les pixels traitent du véritable framebuffer 1920x1080 sur le périphérique (ou 2208x1242 sur sim). Les choses concernant les points dans UIKit seront traitées avec les limites de 2208x1242 (x3) et seront mises à l’échelle comme il convient sur le périphérique.
Le simulateur n'a pas accès au même matériel que celui qui effectue la mise à l'échelle sur le périphérique et il n'est pas vraiment avantageux de le simuler dans un logiciel, car il produirait des résultats différents de ceux du matériel. Il est donc judicieux de définir les natifBounds de l'écran principal d'un périphérique simulé sur les limites de l'écran principal du périphérique physique.
iOS 8 a ajouté une API à UIScreen (nativeScale et nativeBounds) pour permettre à un développeur de déterminer la résolution de CADisplay correspondant à UIScreen.
Vous pouvez détecter l'iPhone 6 Plus en fonction de son échelle native à l'aide de cette macro:
#define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone)
#define IS_IPHONE_6PLUS (IS_IPHONE && [[UIScreen mainScreen] nativeScale] == 3.0f)
La réponse de Hannes Sverrisson est presque correcte. Le système de coordonnées de l'iPhone 6 est en réalité plus grand que le 5 en utilisant son code:
UIScreen *mainScreen = [UIScreen mainScreen];
NSLog(@"Screen bounds: %@, Screen resolution: %@, scale: %f, nativeScale: %f",
NSStringFromCGRect(mainScreen.bounds), mainScreen.coordinateSpace, mainScreen.scale, mainScreen.nativeScale);
Le système de coordonnées pour les applications fournissant les images de lancement correctes est le suivant:
Taille pour iPhone 6 (Retina HD 4.7) avec mise à l'échelle @ 2x, Espace de coordonnées: 375 x 667 et 750 x 1334 points réels:
Screen bounds: {{0, 0}, {375, 667}}, Screen resolution: <UIScreen: 0x7fa01b5182d0; bounds = {{0, 0}, {375, 667}};
mode = <UIScreenMode: 0x7fa01b711760; size = 750.000000 x 1334.000000>>, scale: 2.000000, nativeScale: 2.000000
Taille pour iPhone 6 Plus (Retina HD 5.5) avec mise à l'échelle @ 3x, Espace de coordonnées: 414 x 736 et 1242 x 2208 points réels:
Screen bounds: {{0, 0}, {414, 736}}, Screen resolution: <UIScreen: 0x7f97fad330b0; bounds = {{0, 0}, {414, 736}};
mode = <UIScreenMode: 0x7f97fae1ce00; size = 1242.000000 x 2208.000000>>, scale: 3.000000, nativeScale: 3.000000
Je devais détecter l'iPhone 6 Plus dans une application construite avec iOS 7. Étant donné que nativeScale n'est pas disponible sur [UIScreen mainScreen], j'ai essayé d'utiliser l'échelle [UIScreen mainScreen]], mais cela vient de revenir à 2.0 ..__ avec cette solution pour détecter l'iPhone 6 Plus sur iOS 7 (devrait également fonctionner sur iOS 8):
-(BOOL)iPhone6Plus{
BOOL isiPhone6Plus = NO;
SEL selector = NSSelectorFromString(@"scale");
if ([[UIScreen mainScreen] respondsToSelector:selector]) {
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:
[[[UIScreen mainScreen] class] instanceMethodSignatureForSelector:selector]];
[invocation setSelector:selector];
[invocation setTarget:[UIScreen mainScreen]];
[invocation invoke];
float returnValue;
[invocation getReturnValue:&returnValue];
if (returnValue == 3.0) {
isiPhone6Plus = YES;
}
NSLog(@"ScaleFactor %1.2f", returnValue);
}
return isiPhone6Plus;
}
La partie intéressante de ce code est que si j'utilise NSInvocation, la valeur de retour du sélecteur d'échelle sera 3.0. L'appel de cette méthode directement sur iOS 7 renvoie 2.0.
Voici ce que j'utilise dans mon application avec iOS 8:
window=[[[UIApplication sharedApplication] windows] firstObject];
NSLog(@"screenHeight=%f width=%f",window.frame.size.height,window.frame.size.width);
if (window.frame.size.height == 480) {
do stuff here...
}
Avant Xcode6/iOS 8, je l’utilisais, mais les limites de l’écran ne fonctionnaient pas correctement avec le simulateur redimensionnable ou du moins, cela ne fonctionnait pas dans les versions bêta de Xcode6 ...
CGRect screenBounds=[[UIScreen mainScreen] bounds];
if (screenBounds.size.height >= 568) {
do stuff here...
}
pour moi cela fonctionne pour moi
if(UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone){
UIStoryboard *storyBoard;
CGSize result = [[UIScreen mainScreen] bounds].size;
CGFloat scale = [UIScreen mainScreen].scale;
result = CGSizeMake(result.width * scale, result.height * scale);
if(result.height == 1136){
storyBoard = [UIStoryboard storyboardWithName:@"Main_iPhone_5" bundle:nil];
UIViewController *initViewController = [storyBoard instantiateInitialViewController];
[self.window setRootViewController:initViewController];
} else if(result.height == 1334){
storyBoard = [UIStoryboard storyboardWithName:@"Main_iPhone_6" bundle:nil];
UIViewController *initViewController = [storyBoard instantiateInitialViewController];
[self.window setRootViewController:initViewController];
} else if(result.height == 2208){
storyBoard = [UIStoryboard storyboardWithName:@"Main_iPhone_6_plus" bundle:nil];
UIViewController *initViewController = [storyBoard instantiateInitialViewController];
[self.window setRootViewController:initViewController];
} else if(result.height == 960){
storyBoard = [UIStoryboard storyboardWithName:@"Main_iPhone_4" bundle:nil];
UIViewController *initViewController = [storyBoard instantiateInitialViewController];
[self.window setRootViewController:initViewController];
}
} else {
UIStoryboard *storyBoard;
storyBoard = [UIStoryboard storyboardWithName:@"Main_iPad" bundle:nil];
UIViewController *initViewController = [storyBoard instantiateInitialViewController];
[self.window setRootViewController:initViewController];
}
Les trois appareils ont (à peu près) le même nombre de points par pouce. Ainsi, vos images auront automatiquement la même taille physique.
Utilisez [[UIScreen mainScreen] bounds] pour obtenir le nombre total de points à l'écran. Divisez par 163 pour obtenir la taille approximative en pouces si vous le voulez vraiment.
Notez que le 6+ ne renvoie pas 1080p car il ne restitue pas dans une mémoire tampon 1080p. La restitution est telle que la sortie est d’environ 160 points par pouce, en utilisant des ressources @ 3x.
Pas besoin de deviner.
Par exemple. si vous écrivez ce code:
UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 163, 163)];
view.backgroundColor = [UIColor redColor];
[self.view addSubview:view];
Vous obtiendrez une vue à peu près de la même taille physique - un pouce carré - sur tous les appareils iOS.
Apple a déjà fait le travail difficile, alors vous n’avez pas à le faire.
Une chose intéressante à retenir lors de la lecture de tailles d'écran sur mon iPhone 6 Plus est que, lorsque vous le définissez en mode "Zoomé", il s'affiche comme une hauteur pour l'iPhone 6 (667) et lorsqu'il est défini sur "Standard", apparaîtra comme (736). Cela ne devrait pas vraiment avoir d’importance, mais si vous vouliez connaître le type de périphérique pour une raison quelconque (Peut-être le reporting), cela pourrait vous tromper.
Voir this .
Voici le code source mis à jour que vous utilisez this .
les modèles iPhone 6 et iPhone 6 Plus ont été ajoutés.
cela est garanti pour compiler dans xcode 5 (xocde 6 à ce stade est encore floconneux, et vous ne pouvez pas soumettre un ipa à iTunes Connect pour approbation par App Store à l'aide du logiciel bêta, lequel xcode 6 est en ce moment)
la chose est xcode 5 ne reconnaîtra pas le sélecteur nativeScale .. voici comment vous pouvez le faire dans le temps d'exécution:
+ (BOOL)isIphone6Plus
{
SEL selector = NSSelectorFromString(@"nativeScale");
if ([[UIScreen mainScreen] respondsToSelector:selector]) {
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:
[[[UIScreen mainScreen] class] instanceMethodSignatureForSelector:selector]];
[invocation setSelector:selector];
[invocation setTarget:[UIScreen mainScreen]];
[invocation invoke];
float returnValue;
[invocation getReturnValue:&returnValue];
NSLog(@"::: this is native scale %f", returnValue);
return (returnValue == 3.0f);
} else {
// iphone 6 plus come prepackaged with iOS8..
// so if the phone doesn't know what nativeScale means
// it's not an iphone6plus phone
return NO;
}
}
Une chose importante que les réponses ci-dessus omettent est le fait que, dans iOS7 et inférieur, lorsque vous vérifiez [[UIScreen mainScreen] bounds] pour les limites de l'écran, la largeur et la hauteur sont toujours identiques, quelle que soit l'orientation du téléphone. un iPhone5 en mode paysage, il indiquera toujours la largeur 320 et la hauteur 568. Dans iOS8, cela a changé. Désormais, si ce même iPhone5 est en mode paysage, il affiche la largeur 568 et la hauteur 320. Vous trouverez ci-dessous les méthodes qui compte pour cela:
+ (BOOL) deviceHasFourInchScreen
{
return [DeviceType deviceHasScreenWithIdiom:UIUserInterfaceIdiomPhone scale:2.0 height:568.0];
}
+ (BOOL) deviceHasFourPointSevenInchScreen
{
return [DeviceType deviceHasScreenWithIdiom:UIUserInterfaceIdiomPhone scale:2.0 height:667.0];
}
+ (BOOL) deviceHasFivePointFiveInchScreen
{
return [DeviceType deviceHasScreenWithIdiom:UIUserInterfaceIdiomPhone scale:3.0 height:736.0];
}
+ (BOOL) deviceHasScreenWithIdiom:(UIUserInterfaceIdiom)userInterfaceIdiom scale:(CGFloat)scale height:(CGFloat)height
{
CGRect mainScreenBounds = [[UIScreen mainScreen] bounds];
CGFloat mainScreenHeight;
if ([OperatingSystemVersion operatingSystemVersionLessThan:@"8.0"])
{
mainScreenHeight = mainScreenBounds.size.height;
}
else
{
mainScreenHeight = (UIDeviceOrientationIsLandscape([[UIApplication sharedApplication] statusBarOrientation])) ? mainScreenBounds.size.width : mainScreenBounds.size.height;
}
if ([[UIDevice currentDevice] userInterfaceIdiom] == userInterfaceIdiom && [[UIScreen mainScreen] scale] == scale && mainScreenHeight == height)
{
return YES;
}
else
{
return NO;
}
}
Voici également les méthodes de classe OperatingSystem associées:
+ (NSString *) currentOperatingSystemVersion
{
return [[UIDevice currentDevice] systemVersion];
}
+ (BOOL) operatingSystemVersionLessThanOrEqualTo:(NSString *) operatingSystemVersionToCompare
{
return ([[self currentOperatingSystemVersion] compare: operatingSystemVersionToCompare options:NSNumericSearch] != NSOrderedDescending);
}
Swift 4
if(kSize.width == 320){
//iphone se
}else if(kSize.width == 375 && kSize.height == 667){
//iphone 7 / 8
}else if(kSize.width == 375){
//iphone x
}else if(kSize.width == 414){
//iphone 7 plus/ 8 plus
}
kSize est l'écran CGSize
laissez kSize = UIScreen.main.bounds.size