it-swarm.com.de

Wie erkennt man ein iPhone 5 (Widescreen-Geräte)?

Ich habe gerade ein Upgrade auf XCode 4.5 durchgeführt GM) und festgestellt, dass Sie jetzt die Größe 4 "Retina auf Ihren View Controller im Storyboard anwenden können.

Wenn ich jetzt eine Anwendung erstellen möchte, die sowohl auf dem iPhone 4 als auch auf dem iPhone 5 ausgeführt wird, muss ich natürlich jedes Fenster zweimal erstellen, aber ich muss auch erkennen, ob der Benutzer ein iPhone mit einem 3,5 "- oder 4" -Bildschirm hat, und dann das anwenden Aussicht.

Wie soll ich das machen

300
Finn Gaida

Zunächst sollten Sie nicht alle Ansichten neu erstellen, um sie an einen neuen Bildschirm anzupassen, und auch nicht unterschiedliche Ansichten für unterschiedliche Bildschirmgrößen verwenden.

Verwenden Sie die Funktionen zur automatischen Größenänderung von iOS, damit Ihre Ansichten jede Bildschirmgröße anpassen und anpassen können.

Das ist nicht sehr schwer, lies etwas Dokumentation darüber. Das spart Ihnen viel Zeit.

iOS 6 bietet dazu auch neue Funktionen.
Lesen Sie unbedingt das iOS 6 API-Änderungsprotokoll auf Apple Entwickler-Website.
Und überprüfen Sie die neuen iOS 6 AutoLayout -Funktionen.

Das heißt, wenn Sie das iPhone 5 wirklich erkennen müssen, können Sie sich einfach auf die Bildschirmgröße verlassen.

[ [ UIScreen mainScreen ] bounds ].size.height

Der Bildschirm des iPhone 5 hat eine Höhe von 568.
Sie können sich ein Makro vorstellen, um all dies zu vereinfachen:

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

Die Verwendung von fabs mit dem epsilon dient hier der Vermeidung von Präzisionsfehlern beim Vergleich von Gleitkommawerten, wie in den Kommentaren von H2CO3 gezeigt.

Ab jetzt können Sie es in Standard if/else-Anweisungen verwenden:

if( IS_IPHONE_5 )
{}
else
{}

Bearbeiten - Bessere Erkennung

Wie von einigen Leuten angegeben, erkennt dies nur einen Widescreen , kein tatsächliches iPhone 5.

Die nächsten Versionen des iPod touch werden möglicherweise auch einen solchen Bildschirm haben, sodass wir möglicherweise einen anderen Satz von Makros verwenden.

Nennen wir das ursprüngliche Makro IS_WIDESCREEN:

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

Und lassen Sie uns Modellerkennungsmakros hinzufügen:

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

Auf diese Weise können wir sicherstellen, dass wir ein iPhone-Modell [~ # ~] und [~ # ~] als Breitbild haben, und wir können das IS_IPHONE_5 Makro:

#define IS_IPHONE_5 ( IS_IPHONE && IS_WIDESCREEN )

Beachten Sie auch, dass diese Makros, wie von @ LearnCocos2D angegeben, nicht funktionieren, wenn die Anwendung nicht für den iPhone 5-Bildschirm optimiert ist (das Bild [email protected] fehlt), da die Bildschirmgröße in solchen Fällen immer noch 320x480 beträgt ein Fall.

Ich denke nicht, dass dies ein Problem sein könnte, da ich nicht verstehe, warum wir ein iPhone 5 in einer nicht optimierten App erkennen möchten.

WICHTIG - Unterstützung für iOS 8

Unter iOS 8 gibt die Eigenschaft bounds der Klasse UIScreen jetzt die Ausrichtung des Geräts wieder .
Offensichtlich funktioniert der vorherige Code nicht sofort.

Um dies zu beheben, können Sie einfach die neue Eigenschaft nativeBounds anstelle von bounds verwenden, da sie sich nicht mit der Ausrichtung ändert und auf einem Hochformat basiert.
Beachten Sie, dass die Abmessungen von nativeBounds in Pixeln gemessen werden, sodass für ein iPhone 5 die Höhe 1136 anstelle von beträgt 568.

Wenn Sie auch auf iOS 7 oder niedriger abzielen, müssen Sie die Feature-Erkennung verwenden, da das Aufrufen von nativeBounds vor iOS 8 zum Absturz Ihrer App führt:

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

Sie können die vorherigen Makros folgendermaßen anpassen:

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

Wenn Sie ein iPhone 6 oder 6 Plus erkennen müssen, verwenden Sie natürlich die entsprechenden Bildschirmgrößen.

467
Macmade

Getestet und entwickelt für jede Kombination von SDK und Betriebssystem:

Swift

iPad-Typen hinzugefügt. iPad 2 und iPad mini sind iPads ohne Netzhaut. IPad Mini 2 und höher, iPad 3, 4, iPad Air, Air 2, Air 3 und iPad Pro 9.7 haben dieselbe logische Auflösung von 1024. iPad Pro hat eine maximale Länge von 1366. - Referenz

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

Sehen Sie es in Aktion https://Gist.github.com/hfossli/bc93d924649de881ee2882457f14e346

Hinweis: Wenn z. Das iPhone 6 ist im gezoomten Modus. Die Benutzeroberfläche ist eine vergrößerte Version des iPhone 5. Diese Funktionen bestimmen nicht den Gerätetyp, sondern den Anzeigemodus. In diesem Beispiel ist das iPhone 5 das gewünschte Ergebnis.

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

Verwendung: http://pastie.org/9687735

Hinweis: Wenn z. Das iPhone 6 ist im gezoomten Modus. Die Benutzeroberfläche ist eine vergrößerte Version des iPhone 5. Diese Funktionen bestimmen nicht den Gerätetyp, sondern den Anzeigemodus. In diesem Beispiel ist das iPhone 5 das gewünschte Ergebnis.

233
hfossli

Wirklich einfache Lösung

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

Wir müssen jetzt die Bildschirmgrößen für iPhone 6 und 6Plus berücksichtigen. Hier ist eine aktualisierte Antwort

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
}

Einige nützliche Informationen

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"
28
Sam B

Ich habe mir die Freiheit genommen, das Makro von Macmade in eine C-Funktion zu integrieren und es richtig zu benennen, da es Breitbildverfügbarkeit und [~ # ~] nicht [erkennt. ~ # ~] unbedingt das iPhone 5.

Das Makro erkennt auch nicht, dass es auf einem iPhone 5 ausgeführt wird, wenn das Projekt das [email protected] nicht enthält. Ohne das neue Standardbild meldet das iPhone 5 eine normale Bildschirmgröße von 480 x 320 (in Punkten). Die Prüfung erfolgt also nicht nur auf Breitbildverfügbarkeit, sondern auch auf Breitbildmodus ist aktiviert.

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

Hier sind unsere Codes Test bestanden auf ios7/ios8 für iphone4, iphone5, ipad, iphone6, iphone6p, egal auf Geräten oder Simulator:

#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 )
11
Ginger

Ich habe die Antwort von hfossli verwendet und sie in Swift übersetzt

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

das ist das makro für mein cocos2d projekt. sollte für andere Apps gleich sein.

#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))
6
OMGPOP
if ((int)[[UIScreen mainScreen] bounds].size.height == 568)
{
    // This is iPhone 5 screen
} else {
    // This is iPhone 4 screen
}
5
D-eptdeveloper

In Swift, einem iOS 8+ -Projekt möchte ich UIScreen wie folgt erweitern:

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

}

(HINWEIS: nativeBounds ist in Pixel).

Und dann sieht der Code so aus:

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

Der Code macht also deutlich, dass dies eine Prüfung für den Hauptbildschirm ist, nicht für das Gerätemodell.

3
zubko

In Anlehnung an die Antwort von Samrat Mazumdar finden Sie hier eine kurze Methode, mit der die Bildschirmgröße des Geräts geschätzt wird. Es funktioniert mit den neuesten Geräten, kann aber bei zukünftigen Geräten fehlschlagen (wie bei allen Methoden des Erratens). Es wird auch verwirrt, wenn das Gerät gespiegelt wird (gibt die Bildschirmgröße des Geräts zurück, nicht die Größe des gespiegelten Bildschirms).

#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
    }
} 
2
Jeff Hay

Ich fand heraus, dass die Antworten keinen speziellen Fall für Simulatoren beinhalten.

#define IS_WIDESCREEN ( [ [ UIScreen mainScreen ] bounds ].size.height == 568  )
#define IS_IPHONE ([[ [ UIDevice currentDevice ] model ] rangeOfString:@"iPhone"].location != NSNotFound)
#define IS_IPAD ([[ [ UIDevice currentDevice ] model ] rangeOfString:@"iPad"].location != NSNotFound)
#define IS_IPHONE_5 ( IS_IPHONE && IS_WIDESCREEN )
2
valvoline
+(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;

}
2
Mubin Shaikh

Ich denke, es sollte gut sein, wenn dieses Makro in Gerät und Simulator funktioniert, unten sind die Lösung.

#define IS_WIDESCREEN (fabs((double)[[UIScreen mainScreen]bounds].size.height - (double)568) < DBL_EPSILON)
#define IS_IPHONE (([[[UIDevice currentDevice] model] isEqualToString:@"iPhone"]) || ([[[UIDevice currentDevice] model] isEqualToString: @"iPhone Simulator"]))
#define IS_iPod   ([[[UIDevice currentDevice]model] isEqualToString:@"iPod touch"])
#define IS_IPHONE_5 ((IS_IPHONE || IS_iPod) && IS_WIDESCREEN)
2
Bhavesh Dhaduk
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

     }
1
Nithin M Keloth
  1. Füge eine 'Neue Swift Datei' -> AppDelegateEx.Swift

  2. füge eine Erweiterung zu AppDelegate hinzu

    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. verwendungszweck:

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

Auf diese Weise können Sie Gerätefamilien erkennen.

    #import <sys/utsname.h>
    NSString* deviceName()
    {
        struct utsname systemInformation;
        uname(&systemInformation);
        NSString *result = [NSString stringWithCString:systemInformation.machine
                                              encoding:NSUTF8StringEncoding];
        return result;
    }

    #define isIPhone5  [deviceName() rangeOfString:@"iPhone5,"].location != NSNotFound
    #define isIPhone5S [deviceName() rangeOfString:@"iPhone6,"].location != NSNotFound
1
Xeieshan

In Swift 3 können Sie meine einfache Klasse KRDeviceType verwenden.

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

Es ist gut dokumentiert und unterstützt die Operatoren ==,> =, <=.

Um beispielsweise festzustellen, ob das Gerät über iPhone 6/6s/7-Grenzen verfügt, können Sie einfach den nächsten Vergleich durchführen:

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

Um zu erkennen, ob das Gerät Grenzen von iPhone 5/5S/SE oder früher (iPhone 4s) hat, können Sie folgenden Vergleich verwenden:

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

Sich auf die Größe zu verlassen, ist in so vielen Ebenen falsch. Wie wäre es mit einer Frage an das System?

- (NSString *) getDeviceModel
{
    struct utsname systemInfo;
    uname(&systemInfo);
    return [NSString stringWithCString:systemInfo.machine encoding:NSUTF8StringEncoding];
}

Aus Bester Weg, um den Hardwaretyp, iPhone4 oder iPhone5 zu erkennen? , edzio27 Antwort.

1
3d0

Wenn das Projekt mit Xcode 6 erstellt wurde, verwenden Sie den folgenden Code, um die Geräte zu erkennen.

printf("\nDetected Resolution : %d x %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");
}

Wenn das Projekt in Xcode 5 erstellt und in Xcode 6 geöffnet wurde, verwenden Sie den folgenden Code, um die Geräte zu erkennen. (Dieser Code funktioniert, wenn keine Startbilder für iPhone 6,6+ zugewiesen sind

printf("\nDetected Resolution : %d x %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;
}

Wenn Sie immer noch Xcode 5 zusammen verwenden, verwenden Sie den folgenden Code, um die Geräte zu erkennen (iPhone 6 und 6+ werden nicht erkannt)

printf("\nDetected Resolution : %d x %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
Aritra Das

Dies wurde hundertmal beantwortet, aber diese Lösung hat am besten für mich funktioniert und dazu beigetragen, das Problem zu beheben, wenn neue Geräte eingeführt werden und ich keine definierte Größe habe.

Swift 5 Helfer:

extension UIScreen {
    func phoneSizeInInches() -> CGFloat {
        switch (self.nativeBounds.size.height) {
        case 960, 480:
            return 3.5  //iPhone 4
        case 1136:
            return 4    //iPhone 5
        case 1334:
            return 4.7  //iPhone 6
        case 2208:
            return 5.5  //iPhone 6 Plus
        case 2436:
            return 5.8  //iPhone X
        case 1792:
            return 5.5  //iPhone XR
        case 2688:
            return 6.5  //iPhone XS Max
        default:
            let scale = self.scale
            let ppi = scale * 163
            let width = self.bounds.size.width * scale
            let height = self.bounds.size.height * scale
            let horizontal = width / ppi, vertical = height / ppi
            let diagonal = sqrt(pow(horizontal, 2) + pow(vertical, 2))
            return diagonal
        }
    }
}

Dies liegt daran, dass es einfach ist, sich die Zollgrößen eines Telefons zu merken, z. B. "5,5 Zoll" oder "4,7 Zoll", die genauen Pixelgrößen jedoch schwer zu merken.

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

Dies gibt Ihnen auch die Möglichkeit, Folgendes zu tun:

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

Mit Standard: wird versucht, die Bildschirmgröße und -skalierung zu verwenden, um die diagonalen Zoll zu berechnen. In diesem Fall wird versucht, eine neue Gerätegröße zu ermitteln, und der Code, wie im letzten Beispiel, sollte weiterhin funktionieren.

1
William T.

Hier ist der richtige Test des Gerätes, ohne von der Ausrichtung abzuhängen

- (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;
}
0
Pawel Molodkin

benutze den folgenden Code:

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
}
0
user1025285