iphone - que - Detectar la pantalla de la retina

pantalla de retina ventajas

Question

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

Answer 1

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

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
        }

Answer 2

Este es un riff en la respuesta de Matt MC arriba. Sólo una categoría en 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

Answer 3

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 resolución estándar iPhone / iPod touch, 1 para retina iPhone, 2 para resolución estándar iPad, 3 para retina iPad.

Answer 4

Esto funciono para mi

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

Answer 5

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

Entonces en cualquier archivo puedes simplemente hacer:

if(IS_RETINA)
{
   // etc..
}

Answer 6

Para detectar la pantalla Retina de forma confiable en todos los dispositivos iOS, debe verificar si el dispositivo está ejecutando iOS4 + y si la [UIScreen mainScreen].scale es igual a 2.0. NO PUEDES asumir que un dispositivo está ejecutando iOS4 + si existe la propiedad de scale , 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 el iPad: devuelve 1.0 en modo 1x y 2x. Puedes probarlo tú mismo en el simulador.

-displayLinkWithTarget:selector: el -displayLinkWithTarget:selector: 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
}

Answer 7

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

Answer 8

Siempre es un poco peligroso comparar los valores de punto flotante para la igualdad. Prefiero ir para cualquiera

[UIScreen mainScreen].scale > 1.0;

o

[UIScreen mainScreen].scale < 2.0;

Answer 9

Solo para combinar la respuesta de @sickp y el siguiente comentario de @ n13, convertí esto en una categoría de UIScreen que parece funcionar bien. La comprobació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

Podría ser útil para alguien.

Answer 10

Versión modificada de primulaveris para simplificar la mayoría de los casos de uso 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 úsalos así

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

Answer 11

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
}

Answer 12

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

Answer 13

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

Answer 14

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