web-dev-qa-db-fra.com

Détecter l'affichage de la rétine

Le SDK iOS offre-t-il un moyen simple de vérifier si le périphérique en cours possède un écran haute résolution (rétine)?

Le meilleur moyen que j'ai trouvé de le faire maintenant est:

    if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)] == YES && [[UIScreen mainScreen] scale] == 2.00) {
         // RETINA DISPLAY
    }
iosiphoneretina-displayuiscreen
221
Pierre Valade

Afin de détecter de manière fiable l'affichage Retina sur tous les périphériques iOS, vous devez vérifier si le périphérique exécute iOS4 + et si la propriété [UIScreen mainScreen].scale est égale à 2.0. Vous NE POUVEZ PAS présumer qu'un appareil exécute iOS4 + si la propriété scale existe, car l'iPad 3.2 contient également cette propriété.

Sur un iPad sous iOS3.2, la balance retournera 1.0 en mode 1x et 2.0 en mode 2x, même si nous savons que cet appareil ne contient pas d'écran Retina. Apple a changé ce comportement dans iOS4.2 pour l'iPad: il renvoie 1.0 en modes 1x et 2x. Vous pouvez le tester vous-même dans le simulateur.

Je teste la méthode -displayLinkWithTarget:selector: sur l'écran principal existant dans iOS4.x mais pas iOS3.2, puis vérifie l'échelle de l'écran:

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

La réponse de @ sickp est correcte. Juste pour faciliter les choses, ajoutez cette ligne dans votre fichier Shared.pch:

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

Ensuite, dans n'importe quel fichier, vous pouvez simplement faire:

if(IS_RETINA)
{
   // etc..
}
79
Mick Byrne
+(BOOL)iPhoneRetina{
    return ([[UIScreen mainScreen] respondsToSelector:@selector(displayLinkWithTarget:selector:)] && ([UIScreen mainScreen].scale == 2.0))?1:0;
}
20
Mani

Voici une extension pratique Swift:

Mise à jour pour 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 >= 2.0
    }

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

Usage:

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

Usage:

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

Cet extrait ...

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

J'y retournerai ... 0 pour un iPhone/iPod touch de résolution standard, 1 pour un iPhone retina, 2 pour un iPad de résolution standard, 3 pour un iPad rétina.

6
Pedro

SSToolkit a une méthode qui fait ceci:

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

Il est utilisé de la manière suivante:

[[UIScreen mainScreen] isRetinaDisplay];
6
Jorge Perez

Il est toujours un peu risqué de comparer les valeurs à virgule flottante pour l’égalité. Je préfère aller pour soit

[UIScreen mainScreen].scale > 1.0;

ou

[UIScreen mainScreen].scale < 2.0;
5
skahlert

Version rapide des réponses ci-dessus, avec une échelle> = 2.0, de sorte qu'elle intègre l'iPhone 6+ et d'autres futurs appareils dotés d'une échelle supérieure à Retina:

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

Ceci est un riff sur la réponse de Matt MC ci-dessus. Juste une catégorie sur 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
2
Dan Rosenstark
// .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;
}
1
Roman Solodyashkin

Juste pour combiner la réponse de @sickp et le commentaire suivant de @ n13, j'ai transformé cela en une catégorie UIScreen qui semble bien fonctionner. La vérification est effectuée la première fois que vous l'appelez, puis enregistrée pour des appels ultérieurs.

@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

Pourrait être utile à quelqu'un.

1
Matt Mc

essaye ça

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

Cela a fonctionné pour moi

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

Version modifiée de primulaveris pour simplifier les cas d'utilisation les plus courants. Je suis sur Swift 2.2 mais cela ne devrait pas avoir d'importance.

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

Ensuite, utilisez-les simplement comme ceci

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