Detectar pantalla Retina

¿IOS SDK proporciona una manera fácil de verificar si el dispositivo actual tiene una pantalla de alta resolución (retina)?

La mejor manera que he encontrado para hacerlo ahora es:

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

Para detectar la pantalla Retina de manera confiable en todos los dispositivos iOS, debe verificar si el dispositivo ejecuta iOS4 + y si la [UIScreen mainScreen].scalepropiedad es igual a 2.0. NO PUEDE asumir que un dispositivo está ejecutando iOS4 + si la scalepropiedad existe, ya que el iPad 3.2 también contiene esta propiedad.

En un iPad con iOS3.2, la escala devolverá 1.0 en modo 1x y 2.0 en modo 2x, aunque sabemos que el dispositivo no contiene una pantalla Retina. Apple cambió este comportamiento en iOS4.2 para iPad: devuelve 1.0 en los modos 1x y 2x. Puede probar esto usted mismo en el simulador.

-displayLinkWithTarget:selector:Pruebo el método en la pantalla principal que existe en iOS4.x pero no en iOS3.2, y luego verifico la escala de la pantalla:

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

La respuesta de @ sickp es correcta. Solo para facilitar las cosas, agregue esta línea en su archivo Shared.pch:

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

Luego, en cualquier archivo, simplemente puede hacer:

if(IS_RETINA)
{
   // etc..
}

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

Aquí hay una práctica extensión rápida:

Actualización para 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
    }
}

Uso:

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

Uso:

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

Este fragmento ...

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

Volverá ... 0 para iPhone / iPod touch de resolución estándar, 1 para iPhone de retina, 2 para iPad de resolución estándar, 3 para iPad de retina.

SSToolkit tiene un método que hace esto:

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

Se utiliza de la siguiente manera:

[[UIScreen mainScreen] isRetinaDisplay];

Siempre se siente un poco dudoso comparar los valores de coma flotante para la igualdad. Prefiero ir por cualquiera

[UIScreen mainScreen].scale > 1.0;

o

[UIScreen mainScreen].scale < 2.0;

Este es un riff en la respuesta de Matt MC anterior. Solo una categoría 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

Versión rápida de las respuestas anteriores, con una escala> = 2.0, por lo que incluye iPhone 6+ y otros dispositivos futuros con una escala superior a Retina:

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

Solo para combinar la respuesta de @sickp y el siguiente comentario de @ n13, convertí esto en una categoría UIScreen que parece funcionar bien. La verificación se realiza la primera vez que la llama y luego se guarda para llamadas posteriores.

@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

Puede ser útil para alguien.

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

prueba esto

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

Versión modificada de primulaveris para simplificar los casos de uso más comunes. Estoy en Swift 2.2 pero no debería importar.

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

Entonces simplemente utilízalos así

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

Esto funciono para mi

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