Netzhautanzeige erkennen

Bietet das iOS SDK eine einfache Möglichkeit, um zu überprüfen, ob das aktuelle Gerät über ein hochauflösendes Display (Retina) verfügt?

Der beste Weg, den ich jetzt gefunden habe, ist:

    if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)] == YES && [[UIScreen mainScreen] scale] == 2.00) {
         // RETINA DISPLAY
    }

Um die Retina-Anzeige auf allen iOS-Geräten zuverlässig zu erkennen, müssen Sie überprüfen, ob auf dem Gerät iOS4 + ausgeführt wird und ob die [UIScreen mainScreen].scaleEigenschaft gleich 2.0 ist. Sie können NICHT davon ausgehen, dass auf einem Gerät iOS4 + ausgeführt wird, wenn die scaleEigenschaft vorhanden ist, da das iPad 3.2 diese Eigenschaft ebenfalls enthält.

Auf einem iPad mit iOS3.2 gibt die Skalierung im 1x-Modus 1.0 und im 2x-Modus 2.0 zurück - obwohl wir wissen, dass das Gerät kein Retina-Display enthält. Apple hat dieses Verhalten in iOS4.2 für das iPad geändert: Es gibt 1.0 sowohl im 1x- als auch im 2x-Modus zurück. Sie können dies selbst im Simulator testen.

Ich -displayLinkWithTarget:selector:teste die Methode auf dem Hauptbildschirm, der in iOS4.x, aber nicht in iOS3.2 vorhanden ist, und überprüfe dann die Skalierung des Bildschirms:

if ([[UIScreen mainScreen] respondsToSelector:@selector(displayLinkWithTarget:selector:)] &&
    ([UIScreen mainScreen].scale == 2.0)) {
  // Retina display
} else {
  // non-Retina display
}

Die Antwort von @ sickp ist richtig. Fügen Sie diese Zeile zur Vereinfachung in Ihre Shared.pch-Datei ein:

#define IS_RETINA ([[UIScreen mainScreen] respondsToSelector:@selector(displayLinkWithTarget:selector:)] && ([UIScreen mainScreen].scale >= 2.0))

Dann können Sie in jeder Datei einfach Folgendes tun:

if(IS_RETINA)
{
   // etc..
}

+(BOOL)iPhoneRetina{
    return ([[UIScreen mainScreen] respondsToSelector:@selector(displayLinkWithTarget:selector:)] && ([UIScreen mainScreen].scale == 2.0))?1:0;
}

Hier ist eine praktische schnelle Erweiterung:

Update für Swift v5:

extension UIScreen {

    public var isRetina: Bool {
        guard let scale = screenScale else {
            return false
        }
        return scale >= 2.0
    }

    public var isRetinaHD: Bool {
        guard let scale = screenScale else {
            return false
        }
        return scale >= 3.0
    }

    private var screenScale: CGFloat? {
        guard UIScreen.main.responds(to: #selector(getter: scale)) else {
            return nil
        }
        return UIScreen.main.scale
    }
}

Verwendung:

if UIScreen.main.isRetina {
    // Your code
}

Original:

extension UIScreen { 
public func isRetina() -> Bool {
    return screenScale() >= 2.0
}

public func isRetinaHD() -> Bool {
    return screenScale() >= 3.0
}

private func screenScale() -> CGFloat? {
    if UIScreen.mainScreen().respondsToSelector(Selector("scale")) {
        return UIScreen.mainScreen().scale
    }
    return nil
    }
}

Verwendung:

if UIScreen.mainScreen().isRetina() {
 // your code
        }

Dieser Ausschnitt ...

    int d = 0; // standard display
if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)] && [[UIScreen mainScreen] scale] == 2.0) {
    d = 1; // is retina display
}

if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPad) {
    d += 2;
}

Wird zurückgegeben ... 0 für iPhone / iPod touch mit Standardauflösung, 1 für iPhone mit Netzhaut, 2 für iPad mit Standardauflösung, 3 für iPad mit Netzhaut.

SSToolkit hat eine Methode, die dies tut:

http://sstoolk.it/documentation/Categories/UIScreen(SSToolkitAdditions).html

Es wird folgendermaßen verwendet:

[[UIScreen mainScreen] isRetinaDisplay];

Es ist immer etwas zwielichtig, Gleitkommawerte auf Gleichheit zu vergleichen. Ich gehe lieber für beides

[UIScreen mainScreen].scale > 1.0;

oder

[UIScreen mainScreen].scale < 2.0;

Dies ist ein Riff zu Matt MCs Antwort oben. Nur eine Kategorie auf UIScreen.

#import "UIScreen+Util.h"

@implementation UIScreen (Util)

+ (BOOL) isRetinaDisplay {
    static BOOL retina = NO;
    static BOOL alreadyChecked = NO;
    if (!alreadyChecked) {
        UIScreen *mainScreen = self.mainScreen;
        if (mainScreen) {
            retina = mainScreen.scale > 1.0;
            alreadyChecked = YES;
        }
    }
    return retina;
}

@end

Schnelle Version der obigen Antworten mit einer Skala von> = 2,0, sodass das iPhone 6+ und andere zukünftige Geräte mit einer Skala über der Retina enthalten sind:

 if UIScreen.mainScreen().respondsToSelector(Selector("scale")) && UIScreen.mainScreen().scale >= 2.0 {
    // code executed only on Retina device
}

Um die Antwort von @sickp und den folgenden Kommentar von @ n13 zu kombinieren, habe ich dies zu einer UIScreen-Kategorie gemacht, die anscheinend gut funktioniert. Die Prüfung wird beim ersten Aufruf durchgeführt und dann für spätere Anrufe gespeichert.

@interface UIScreen (RetinaCheck)
+ (BOOL)retinaScreen;
@end

static BOOL isRetinaScreen = NO;
static BOOL didRetinaCheck = NO;

@implementation UIScreen (RetinaCheck)
+ (BOOL)retinaScreen
{
    if (!didRetinaCheck) {
        isRetinaScreen = ([[self mainScreen] respondsToSelector:@selector(displayLinkWithTarget:selector:)] &&
                          ([self mainScreen].scale == 2.0));
        didRetinaCheck = YES;
    }
    return isRetinaScreen;
}
@end

Könnte für jemanden nützlich sein.

// .h
UIKIT_EXTERN bool isRetinaDisplay();

// .m
bool isRetinaDisplay()
{
    static bool flag;
#ifdef __BLOCKS__
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        if([[UIScreen mainScreen] respondsToSelector:@selector(scale)])
        {
            flag = [[UIScreen mainScreen] scale] > 1.0;
        }
        else
        {
            flag = false;
        }
    });
#else
    static bool onceToken;
    if(onceToken == false)
    {
        onceToken = true;
        if([[UIScreen mainScreen] respondsToSelector:@selector(scale)])
        {
            flag = [[UIScreen mainScreen] scale] > 1.0;
        }
        else
        {
            flag = false;
        }
    }
#endif
    return flag;
}

Versuche dies

if ([[UIScreen mainScreen] respondsToSelector:@selector(displayLinkWithTarget:selector:)] &&
    ([UIScreen mainScreen].scale == 2.0))
{
    // Retina display
    NSLog(@"---------------Retina display");
} else {
    // non-Retina display
    NSLog(@"---------------non-Retina display");
}

Modifizierte Version von Primulaveris zur Vereinfachung der häufigsten Anwendungsfälle. Ich bin auf Swift 2.2, aber es sollte keine Rolle spielen.

extension UIScreen {
    static var isRetina: Bool {
        return screenScale >= 2.0
    }

    static var isRetinaHD: Bool {
        return screenScale >= 3.0
    }

    static var screenScale:CGFloat {
        return UIScreen.mainScreen().scale
    }
}

Dann benutze sie einfach so

print(UIScreen.isRetina)
print(UIScreen.isRetinaHD)
print(UIScreen.screenScale)

Das hat bei mir funktioniert

if((UIScreen .mainScreen().scale) < 2.0)
{
    NSLog("no retina");
}
else
{
    NSLog("retina");
}