web-dev-qa-db-fra.com

Comment détecter l'iPhone 5 (appareils à écran large)?

Je viens de passer à XCode 4.5 GM et j'ai découvert que vous pouvez maintenant appliquer la taille "4" "Retina" à votre contrôleur de vue dans le story-board.

Maintenant, si je veux créer une application qui s'exécute sur les iPhone 4 et 5, je dois bien sûr construire chaque fenêtre deux fois, mais je dois également détecter si l'utilisateur a un iPhone avec un écran de 3,5 "ou 4", puis appliquer la vue.

Comment devrais-je faire ça?

iphoneiosobjective-cscreendevice
300
Finn Gaida

Tout d’abord, vous ne devez pas reconstruire toutes vos vues pour les adapter à un nouvel écran, ni utiliser des vues différentes pour des tailles d’écran différentes.

Utilisez les fonctionnalités de redimensionnement automatique d'iOS pour permettre à vos vues de s'ajuster et d'adapter toute taille d'écran.

Ce n'est pas très difficile, lisez ne documentation à ce sujet. Cela vous fera gagner beaucoup de temps.

iOS 6 offre également de nouvelles fonctionnalités à ce sujet.
Assurez-vous de lire le journal des modifications de l'API iOS 6 sur Apple site Web du développeur.
Et vérifiez les nouvelles capacités iOS 6 AutoLayout .

Cela dit, si vous devez vraiment détecter l'iPhone 5, vous pouvez simplement vous fier au taille de l'écran .

[ [ UIScreen mainScreen ] bounds ].size.height

La hauteur de l'écran de l'iPhone 5 est de 568.
Vous pouvez imaginer une macro, pour simplifier tout cela:

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

L'utilisation de fabs avec epsilon est là pour éviter les erreurs de précision, lors de la comparaison de points flottants, comme indiqué dans les commentaires par H2CO3.

Donc, à partir de maintenant, vous pouvez l’utiliser dans les instructions if/else standard:

if( IS_IPHONE_5 )
{}
else
{}

Éditer - Meilleure détection

Comme indiqué par certaines personnes, cela ne fait que détecter un écran large , pas un iPhone 5 réel.

Les prochaines versions de l'iPod touch auront peut-être aussi un tel écran, nous pourrons donc utiliser un autre ensemble de macros.

Renommons la macro d'origine IS_WIDESCREEN:

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

Et ajoutons des macros de détection de modèle:

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

De cette façon, nous pouvons nous assurer que nous avons un modèle iPhone ET un écran large et nous pouvons redéfinir la macro IS_IPHONE_5:

#define IS_IPHONE_5 ( IS_IPHONE && IS_WIDESCREEN )

Notez également que, comme indiqué par @ LearnCocos2D, ces macros ne fonctionneront pas si l'application n'est pas optimisée pour l'écran de l'iPhone 5 (sans l'image [email protected]), car la taille de l'écran sera toujours de 320x480. un cas.

Je ne pense pas que cela puisse être un problème, car je ne vois pas pourquoi nous voudrions détecter un iPhone 5 dans une application non optimisée.

IMPORTANT - Prise en charge d'iOS 8

Sur iOS 8, la propriété bounds de la classe UIScreen reflète désormais l'orientation du périphérique .
Donc, évidemment, le code précédent ne fonctionnera pas immédiatement.

Pour résoudre ce problème, vous pouvez simplement utiliser la nouvelle propriété nativeBounds à la place de bounds, car elle ne changera pas avec l'orientation et sera basée sur un mode portrait.
Notez que les dimensions de nativeBounds sont mesurées en pixels. Ainsi, pour un iPhone 5, la hauteur sera 1136 au lieu de 568. .

Si vous ciblez également iOS 7 ou une version antérieure, veillez à utiliser la détection de fonctionnalité, car appeler nativeBounds avant iOS 8 plantera votre application:

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

Vous pouvez adapter les macros précédentes de la manière suivante:

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

Et évidemment, si vous devez détecter un iPhone 6 ou 6 Plus, utilisez les tailles d'écran correspondantes.

467
Macmade

Testé et conçu pour toute combinaison de SDK et de système d'exploitation:

Swift

Ajout des types d'iPad. iPad 2 et iPad mini sont des iPad non rétiniens. Alors que les iPad Mini 2 et suivants, les iPad 3, 4, iPad Air, Air 2, Air 3 et iPad Pro 9.7 ont la même résolution logique de 1024. iPad Pro a une longueur maximale de 1366. - référence

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

Regardez-le en action https://Gist.github.com/hfossli/bc93d924649de881ee2882457f14e346

Remarque: Si par exemple L'iPhone 6 est en mode zoomé L'interface utilisateur est une version agrandie de l'iPhone 5. Ces fonctions ne déterminent pas le type d'appareil, mais le mode d'affichage est donc le résultat souhaité dans cet exemple.

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

Utilisation: http://pastie.org/9687735

Remarque: Si par exemple L'iPhone 6 est en mode zoomé L'interface utilisateur est une version agrandie de l'iPhone 5. Ces fonctions ne déterminent pas le type d'appareil, mais le mode d'affichage est donc le résultat souhaité dans cet exemple.

233
hfossli

Solution vraiment simple

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

Nous devons maintenant prendre en compte les tailles d'écran iPhone 6 et 6Plus. Voici une réponse mise à jour

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
}

Quelques informations utiles

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

J'ai pris la liberté de mettre la macro créée par Mac made dans une fonction C et de la nommer correctement car elle détecte disponibilité sur écran large et PAS nécessairement l'iPhone 5.

La macro ne détecte pas non plus l'exécution sur un iPhone 5 dans le cas où le projet n'inclut pas le [email protected]. Sans la nouvelle image par défaut, l'iPhone 5 affichera une taille d'écran normale de 480x320 (en points). La vérification ne concerne donc pas uniquement la disponibilité de l’écran large, mais également le mode écran large est activé.

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

Voici nos codes, test passé sur ios7/ios8 pour iphone4, iphone5, ipad, iphone6, iphone6p, peu importe sur les appareils ou le simulateur:

#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

J'ai utilisé la réponse de hfossli et l'ai traduite en Swift

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

c'est la macro de mon projet cocos2d. devrait être le même pour les autres applications.

#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

Dans Swift, le projet iOS 8+, j'aime bien faire une extension sur UIScreen, comme:

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

}

(REMARQUE: nativeBounds est en pixels).

Et puis le code sera comme:

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

Le code indique donc clairement qu'il s'agit d'une vérification de l'écran principal et non du modèle de périphérique.

3
zubko

Reprenant la réponse de Samrat Mazumdar, voici une courte méthode permettant d’estimer la taille de l’écran du périphérique. Cela fonctionne avec les derniers appareils, mais peut échouer avec les futurs (comme toutes les méthodes de devinettes le pourraient). Cela entraînera également une certaine confusion si le périphérique est mis en miroir (renvoie la taille de l'écran du périphérique, pas la taille de l'écran en miroir).

#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

J'ai trouvé que les réponses n'incluent pas de cas particulier pour les simulateurs.

#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

Je pense que cela devrait être bon si cette macro fonctionnera dans un appareil et un simulateur, voici la solution.

#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. Ajouter un 'Nouveau Swift Fichier' -> AppDelegateEx.Swift

  2. ajouter une extension à AppDelegate

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

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

De cette façon, vous pouvez détecter la famille de périphériques.

    #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

Dans Swift 3, vous pouvez utiliser ma classe simple KRDeviceType.

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

Il est bien documenté et supporte les opérateurs ==,> =, <=.

Par exemple, pour détecter si un appareil est lié à l'iPhone 6/6s/7, vous pouvez simplement utiliser la comparaison suivante:

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

Pour détecter si un appareil est lié à l'iPhone 5/5S/SE ou à une version antérieure (iPhone 4), vous pouvez utiliser la comparaison suivante:

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.

Se fier à la taille est une erreur à bien des égards. Que diriez-vous nous demandons au système?

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

Tiré de Meilleur moyen de détecter le type de matériel, iPhone4 ou iPhone5? , réponse edzio27.

1
3d0

Si le projet est créé avec Xcode 6, utilisez le code mentionné ci-dessous pour détecter les périphériques ..

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

Si le projet a été créé dans Xcode 5 et ouvert dans Xcode 6, utilisez le code mentionné ci-dessous pour détecter les périphériques. (Ce code fonctionne si aucune image de lancement pour iPhone 6,6+ n'est attribuée)

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

Si vous utilisez toujours Xcode 5 tous ensemble, utilisez le code suivant pour détecter les appareils (les iPhone 6 et 6+ ne seront pas détectés)

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

Cela a été répondu cent fois, mais cette solution a fonctionné au mieux pour moi et a permis de résoudre le problème lorsque de nouveaux appareils sont introduits et que je n'ai pas de taille définie.

Swift 5 Helper:

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

En effet, il est facile de mémoriser les tailles en pouces d'un téléphone, comme les périphériques "5,5 pouces" ou "4,7 pouces", mais il est difficile de se rappeler les tailles de pixels exactes.

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

Cela vous donne également la possibilité de faire quelque chose comme ceci:

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

Le default: essaie d'utiliser la taille et l'échelle de l'écran pour essayer de calculer les pouces diagonaux. Si une nouvelle taille de périphérique apparaît, le système essaiera de déterminer et le code, tel que le dernier exemple, devrait toujours fonctionner.

1
William T.

Voici le test correct de l'appareil, sans dépendre de l'orientation

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

utilisez le code suivant:

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