wake-up-neo.net

Ermitteln der Bildschirmgröße des iPhone 6/6 + in Punktwerten

Angesichts der neu angekündigten iPhone 6 Bildschirmgrößen :

iPhone 6: 1334h * 750w @2x (in points: 667h * 375w)
iPhone 6+: 1920 * 1080 @3x (in points: 640h * 360w)

Ich habe mich gefragt, ob es einen Code gibt, mit dem ich herausfinden kann, welche Bildschirmgröße das Gerät des Benutzers hat, sodass ich UIImages und andere Materialien entsprechend mit dem Gerät des Benutzers anpassen und anpassen kann. 

Bisher habe ich Folgendes verwendet:

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

Sollte ich davon ausgehen, dass iPhone7,1 und iPhone7,2 das iPhone 6 sind, während iPhone7,3 und iPhone7.4 die Pluspunkte sind? Wenn jemand eine konkretere Möglichkeit hat, dies zu sagen, wäre es großartig, danke.!

58
daspianist

Der erste Bildschirm ist der Bildschirm des Geräts. Beachten Sie, dass Startbilder für die neuen Telefone zuvor hinzugefügt werden müssen. Andernfalls läuft die App für ältere Apps im vergrößerten Modus: Hier ist der Code, den ich dazu verwendet habe. Hinweis: Dies funktioniert nur mit Version iOS 8 und höher :

UIScreen *mainScreen = [UIScreen mainScreen];
NSLog(@"Screen bounds: %@, Screen resolution: %@, scale: %f, nativeScale: %f",
          NSStringFromCGRect(mainScreen.bounds), mainScreen.coordinateSpace, mainScreen.scale, mainScreen.nativeScale);

Code zum Erkennen des 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;
}

oder

-(BOOL) iPhone6PlusUnZoomed{
    if ([self iPhone6PlusDevice]){
        if ([UIScreen mainScreen].bounds.size.height > 720.0) return YES;  // Height is 736, but 667 when zoomed.
    }
    return NO;
}

Hinweis: Wenn Sie nach iPhone 6 Plus suchen, verlassen Sie sich zum Anpassen der Benutzeroberfläche nicht auf .nativeScale, da der Simulator und das tatsächliche Gerät unterschiedliche Ergebnisse liefern. Aufgrund des Kommentars unten. Scale ist ein CGFloat und daher sollte Code keine Gleichheit prüfen, da einige Gleitkommazahlen möglicherweise niemals gleich sind.


Nachdem Sie Startbildschirm hinzugefügt haben, können Sie die neuen iPhone-Größen verwenden, andernfalls sieht Ihre App immer noch skaliert aus.

Aktualisiert für die neuen iPhones X ????, X ???? und X ???? Max

Größe für iPhone X ???? Max mit @ 3x Skalierung (Apple-Name: Super Retina HD 6.5-Anzeige "), Koordinatenraum: 414 x 896 Punkte und 1242 x 2688 Pixel, 458 ppi Die physische Größe des Geräts beträgt 3,05 x 6,20 Zoll oder 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

Größe für iPhone X ???? mit @ 2x Skalierung (Apple-Name: Super Retina HD 6,1 "-Anzeige ), Koordinatenraum: 414 x 896 Punkte und 828 x 1792 Pixel, 326 ppi, Die physische Größe des Geräts beträgt 2,98 x 5,94 Zoll oder 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

Größe für iPhone X ???? und iPhone X mit @ 3x Skalierung (Apple-Name: Super-Retina-HD 5,8-Zoll-Display ), Koordinatenraum: 375 x 812 Punkte und 1125 x 2436 Pixel, 458 ppi, Die physische Größe des Geräts beträgt 2,79 x 5,65 Zoll oder 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

Größe für iPhone 8, 7, 6 Plus und iPhone 8, 7, 6S Plus mit @ 3-fach Skalierung (Apple-Name: Retina HD 5.5 ), Koordinatenbereich: 414 x 736 Punkte und 1242 x 2208 Pixel, 401 ppi, Bildschirmgröße ist 2,7 x 4,8 Zoll oder 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

Größe für iPhone 6 und iPhone 6S mit @ 2x Skalierung (Apple-Name: Retina HD 4.7 ), Koordinatenraum: 375 x 667 Punkte und 750 x 1334 Pixel, 326 ppi, physikalische Bildschirmgröße ist 2,3 x 4,1 Zoll oder 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

Und iPhone 5 ist zum Vergleich 640 x 1136, iPhone 4 640 x 960.

Hinweis: Laden Sie LaunchImages hoch. Andernfalls wird die App skaliert ausgeführt und zeigt keine korrekte Skalierung oder Bildschirmgröße an.

Comparing iPhone 6 and 6 Plus

101

Wenn Sie Makros bevorzugen, sind hier diejenigen, mit denen Sie zwischen den iPhone-Modellen unterscheiden können. Diese basieren auf den Punktwerten.

#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)
32
bkhayll

Ich verwende den folgenden Code, um festzustellen, welches Gerät ausgeführt wird (es ist ein bisschen schnell und schmutzig, aber es macht den Trick)

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

(Dies funktioniert nur, wenn das iPhone 6/6 Plus durch Hinzufügen der entsprechenden Begrüßungsbildschirme aktiviert ist.)

18
Roland Keesom

Überprüfen Sie die aktualisierte Liste auf wiki , dort habe ich 7,2 für iPhone 6 und 7,1 für iPhone 6 plus. 

5
user3344236

Auf dem physischen Gerät ist der Bildschirm des iPhone 6 Plus auf 2208 x 1242 und nativeBounds auf 1920 x 1080 begrenzt. Es ist eine Hardware-Skalierung erforderlich, um die Größe an die physische Anzeige anzupassen.

Im Simulator sind die Begrenzungen und die nativeBounds des Hauptbildschirms des iPhone 6 Plus jeweils 2208 x 1242.

Mit anderen Worten ... Videos, OpenGL und andere Dinge, die auf CALayers basieren und Pixel behandeln, werden mit dem realen 1920x1080-Framebuffer auf dem Gerät (oder 2208x1242 auf Sim) umgehen. Dinge, die sich auf Punkte in UIKit beziehen, werden sich mit den 2208x1242 (x3) -Rahmen beschäftigen und werden auf dem Gerät entsprechend skaliert.

Der Simulator hat keinen Zugriff auf die gleiche Hardware, die die Skalierung auf dem Gerät vornimmt, und es hat keinen großen Vorteil, wenn er in Software simuliert wird, da sie andere Ergebnisse erzielen würde als die Hardware. Daher ist es sinnvoll, die nativeBounds des Hauptbildschirms eines simulierten Geräts an die Grenzen des Hauptbildschirms des physischen Geräts zu setzen.

iOS 8 fügte eine API zu UIScreen hinzu (nativeScale und nativeBounds), damit ein Entwickler die Auflösung des CADisplay entsprechend dem UIScreen bestimmen kann.

Mit diesem Makro können Sie das iPhone 6 anhand seiner ursprünglichen Skala erkennen:

#define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone)
#define IS_IPHONE_6PLUS (IS_IPHONE && [[UIScreen mainScreen] nativeScale] == 3.0f)
4
sweepy_

Die Antwort von Hannes Sverrisson ist fast richtig. Das iPhone 6-Koordinatensystem ist tatsächlich größer als das 5s-System.

UIScreen *mainScreen = [UIScreen mainScreen];
NSLog(@"Screen bounds: %@, Screen resolution: %@, scale: %f, nativeScale: %f",
      NSStringFromCGRect(mainScreen.bounds), mainScreen.coordinateSpace, mainScreen.scale, mainScreen.nativeScale);

Das Koordinatensystem für Apps, die die richtigen Startbilder bereitstellen, lautet:

Größe für iPhone 6 (Retina HD 4.7) mit @ 2x Skalierung, Koordinatenraum: 375 x 667 und 750 x 1334 tatsächliche Punkte:

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

Größe für iPhone 6 Plus (Retina HD 5.5) mit @ 3-fach Skalierung, Koordinatenraum: 414 x 736 und 1242 x 2208 Istpunkte:

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
4
Paul Buchanan

Ich musste das iPhone 6 Plus in einer mit iOS 7 erstellten App erkennen. Da nativeScale auf [UIScreen mainScreen] nicht verfügbar ist, habe ich versucht, die [UIScreen mainScreen] -Skala zu verwenden. Dies hat jedoch nur 2.0 ..__ mit dieser Lösung zur Erkennung des iPhone 6 Plus unter iOS 7 (sollte auch unter iOS 8 funktionieren):

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

}

Der interessante Teil dieses Codes besteht darin, dass bei Verwendung von NSInvocation der Rückgabewert des Skalenwählers 3,0 ist. Wenn Sie diese Methode direkt unter iOS 7 aufrufen, wird 2.0 zurückgegeben.

3
Sven

Ich verwende dies in meiner App mit 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... 
    }

Vor Xcode6/iOS 8 habe ich dies verwendet, aber Bildschirmgrenzen funktionieren mit dem anpassbaren Simulator nicht richtig oder zumindest nicht in Xcode6-Betas 

CGRect screenBounds=[[UIScreen mainScreen] bounds];

if (screenBounds.size.height >= 568) {

do stuff here...

}
3
David L

für mich funktioniert das für mich

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

}
2
oscar castellon

Alle drei Geräte haben (fast) dieselbe Anzahl von Punkten pro Zoll. Ihre Bilder haben also automatisch die gleiche physische Größe.

Verwenden Sie [[UIScreen mainScreen] bounds], um die Gesamtzahl der Punkte auf dem Bildschirm abzurufen. Teilen Sie durch 163, um die ungefähre Größe in Zoll zu erhalten, wenn Sie es wirklich wollen.

Beachten Sie, dass das 6+ 1080p nicht zurückgibt, da es nicht in einen 1080p-Puffer gerendert wird. Es wird so ausgegeben, dass die Ausgabe ungefähr 160 Punkte pro Zoll beträgt, wobei @ 3x-Assets verwendet werden.

Keine Notwendigkeit, eine zweite Vermutung zu erraten.

Z.B. wenn Sie diesen Code schreiben:

UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 163, 163)];
view.backgroundColor = [UIColor redColor];
[self.view addSubview:view];

Sie erhalten eine Ansicht, die auf allen iOS-Geräten so ziemlich die gleiche physische Größe hat (ein Zoll Quadrat).

Apple hat die harte Arbeit bereits geleistet, Sie müssen also nicht.

2
Tommy

Beim Lesen der Bildschirmgrößen auf meinem iPhone 6 Plus ist es interessant zu wissen, dass die Einstellung für "Zoomed" auf die Höhe des iPhone 6 (667) und auf "Standard" angezeigt wird erscheint als (736). Sollte eigentlich nicht von Bedeutung sein, aber wenn Sie den Gerätetyp aus irgendeinem Grund speziell wissen wollten (z. B. Reporting), könnte dies Sie täuschen.

Siehe this .

1
Shippy

Hier ist der aktualisierte Quellcode, den Sie this verwenden.

iPhone 6 und iPhone 6 Plus Modelle wurden hinzugefügt.

1
Sergey Filippov

dies wird garantiert in xcode 5 kompiliert (xocde 6 ist an dieser Stelle immer noch unübersichtlich, und Sie können keine ipa an iTunes connect senden, um die Genehmigung für den App Store zu erhalten.

die Sache ist, dass xcode 5 den nativeScale-Selektor nicht erkennt. So können Sie es zur Laufzeit machen:

+ (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;
    }
}
1
abbood

Die Hauptantworten, die die obigen Antworten auslassen, sind die Tatsache, dass in iOS7 und darunter bei der Überprüfung von [[UIScreen mainScreen] bounds] für die Bildschirmgrenzen die Breite und Höhe immer gleich sind, unabhängig von der Ausrichtung des Telefons. Wenn also Bei einem iPhone5 im Querformat wird die Breite immer noch als 320 und die Höhe als 568 angegeben. In iOS8 wurde dies geändert. Wenn sich das gleiche iPhone5 im Querformat befindet, wird die Breite als 568 und die Höhe als 320 angegeben. Nachfolgend sind Methoden aufgeführt welche Rechnung dafür:

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

Hier sind auch die zugehörigen Klassenmethoden von OperatingSystem:

+ (NSString *) currentOperatingSystemVersion
{
    return [[UIDevice currentDevice] systemVersion];
}
+ (BOOL) operatingSystemVersionLessThanOrEqualTo:(NSString *) operatingSystemVersionToCompare
{
    return ([[self currentOperatingSystemVersion] compare: operatingSystemVersionToCompare options:NSNumericSearch] != NSOrderedDescending);    
}
0
Ser Pounce

Schnell 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 ist Bildschirm CGSize  

lassen Sie kSize = UIScreen.main.bounds.size

0
Kishore Kumar