iOS détecte si l'utilisateur est sur un iPad

J'ai une application qui fonctionne sur l'iPhone et l'iPod Touch, elle peut fonctionner sur l'iPad Retina et tout, mais il doit y avoir un ajustement. J'ai besoin de détecter si l'appareil actuel est un iPad. Quel code puis-je utiliser pour détecter si l'utilisateur utilise un iPad sur mon ordinateur UIViewController, puis changer quelque chose en conséquence?

Il existe plusieurs façons de vérifier si un appareil est un iPad. C'est ma façon préférée de vérifier si l'appareil est bien un iPad:

if ( UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad )
{
    return YES; /* Device is iPad */
}

La façon dont je l'utilise

#define IDIOM    UI_USER_INTERFACE_IDIOM()
#define IPAD     UIUserInterfaceIdiomPad

if ( IDIOM == IPAD ) {
    /* do something specifically for iPad. */
} else {
    /* do something specifically for iPhone or iPod touch. */
}   

Autres exemples

if ( [(NSString*)[UIDevice currentDevice].model hasPrefix:@"iPad"] ) {
    return YES; /* Device is iPad */
}

#define IPAD     (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad)
if ( IPAD ) 
     return YES;

Pour une solution Swift, consultez cette réponse: https://stackoverflow.com/a/27517536/2057171

Dans Swift, vous pouvez utiliser les égalités suivantes pour déterminer le type d'appareil sur les applications universelles:

UIDevice.current.userInterfaceIdiom == .phone
// or
UIDevice.current.userInterfaceIdiom == .pad

L'utilisation serait alors quelque chose comme:

if UIDevice.current.userInterfaceIdiom == .pad {
    // Available Idioms - .pad, .phone, .tv, .carPlay, .unspecified
    // Implement your logic here
}

Cela fait partie d'UIDevice à partir d'iOS 3.2, par exemple:

[UIDevice currentDevice].userInterfaceIdiom == UIUserInterfaceIdiomPad

Vous pouvez également utiliser ceci

#define IPAD UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad
...
if (IPAD) {
   // iPad
} else {
   // iPhone / iPod Touch
}

UI_USER_INTERFACE_IDIOM()renvoie iPad uniquement si l'application est pour iPad ou Universal. Si c'est une application iPhone fonctionnant sur un iPad, ce ne sera pas le cas. Vous devriez donc plutôt vérifier le modèle.

Soyez prudent: si votre application cible uniquement les appareils iPhone, l'iPad fonctionnant avec le mode compatible iPhone renverra false pour la déclaration ci-dessous:

#define IPAD     UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad

La bonne façon de détecter un appareil iPad physique est:

#define IS_IPAD_DEVICE      ([(NSString *)[UIDevice currentDevice].model hasPrefix:@"iPad"])

J'ai trouvé qu'une solution ne fonctionnait pas pour moi dans le simulateur dans Xcode. Au lieu de cela, cela fonctionne:

ObjC

NSString *deviceModel = (NSString*)[UIDevice currentDevice].model;

if ([[deviceModel substringWithRange:NSMakeRange(0, 4)] isEqualToString:@"iPad"]) {
    DebugLog(@"iPad");
} else {
    DebugLog(@"iPhone or iPod Touch");
}

Rapide

if UIDevice.current.model.hasPrefix("iPad") {
    print("iPad")
} else {
    print("iPhone or iPod Touch")
}

Dans les «autres exemples» de Xcode, le modèle d'appareil revient en tant que «simulateur d'iPad», donc le réglage ci-dessus devrait trier cela.

De nombreuses façons de le faire dans Swift :

Nous vérifions le modèle ci-dessous (nous ne pouvons faire qu'une recherche sensible à la casse ici):

class func isUserUsingAnIpad() -> Bool {
    let deviceModel = UIDevice.currentDevice().model
    let result: Bool = NSString(string: deviceModel).containsString("iPad")
    return result
}

Nous vérifions le modèle ci-dessous (nous pouvons faire une recherche sensible à la casse / insensible ici):

    class func isUserUsingAnIpad() -> Bool {
        let deviceModel = UIDevice.currentDevice().model
        let deviceModelNumberOfCharacters: Int = count(deviceModel)
        if deviceModel.rangeOfString("iPad",
                                     options: NSStringCompareOptions.LiteralSearch,
                                     range: Range<String.Index>(start: deviceModel.startIndex,
                                                                end: advance(deviceModel.startIndex, deviceModelNumberOfCharacters)),
                                     locale: nil) != nil {
            return true
        } else {
            return false
        }
   }

UIDevice.currentDevice().userInterfaceIdiomci-dessous renvoie uniquement l'iPad si l'application est pour iPad ou Universal. S'il s'agit d'une application iPhone exécutée sur un iPad, ce ne sera pas le cas. Vous devriez donc plutôt vérifier le modèle. :

    class func isUserUsingAnIpad() -> Bool {
        if UIDevice.currentDevice().userInterfaceIdiom == UIUserInterfaceIdiom.Pad {
            return true
        } else {
            return false
        }
   }

Cet extrait ci-dessous ne se compile pas si la classe n'hérite pas d'un UIViewController, sinon cela fonctionne très bien. Indépendamment UI_USER_INTERFACE_IDIOM()ne retourne iPad que si l'application est pour iPad ou Universal. S'il s'agit d'une application iPhone exécutée sur un iPad, ce ne sera pas le cas. Vous devriez donc plutôt vérifier le modèle. :

class func isUserUsingAnIpad() -> Bool {
    if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiom.Pad) {
        return true
    } else {
        return false
    }
}

*

Dans swift 3.0

*

 if UIDevice.current.userInterfaceIdiom == .pad {
        //pad
    } else if UIDevice.current.userInterfaceIdiom == .phone {
        //phone
    } else if UIDevice.current.userInterfaceIdiom == .tv {
        //tv
    } else if UIDevice.current.userInterfaceIdiom == .carPlay {
        //CarDisplay
    } else {
        //unspecified
    }

Beaucoup de réponses sont bonnes mais j'utilise comme ça dans swift 4

1. Créer une constante

   struct App {
       static let isRunningOnIpad = UIDevice.current.userInterfaceIdiom == .pad ? true : false
   }

2. Utilisez comme ça

   if App.isRunningOnIpad {
       return load(from: .main, identifier: identifier)
   } else {
       return load(from: .ipad, identifier: identifier)
   }

Edit: Comme suggéré, Cœur crée simplement une extension sur UIDevice

extension UIDevice {
    static let isRunningOnIpad = UIDevice.current.userInterfaceIdiom == .pad ? true : false
}

Vous pouvez vérifier le rangeOfString pour voir le mot iPad existe comme ceci.

NSString *deviceModel = (NSString*)[UIDevice currentDevice].model;

if ([deviceModel rangeOfString:@"iPad"].location != NSNotFound)  {
NSLog(@"I am an iPad");
} else {
NSLog(@"I am not an iPad");
}

Encore une autre façon Swifty:

//MARK: -  Device Check
let iPad = UIUserInterfaceIdiom.Pad
let iPhone = UIUserInterfaceIdiom.Phone
@available(iOS 9.0, *) /* AppleTV check is iOS9+ */
let TV = UIUserInterfaceIdiom.TV

extension UIDevice {
    static var type: UIUserInterfaceIdiom 
        { return UIDevice.currentDevice().userInterfaceIdiom }
}

Usage:

if UIDevice.type == iPhone {
    //it's an iPhone!
}

if UIDevice.type == iPad {
    //it's an iPad!
}

if UIDevice.type == TV {
    //it's an TV!
}

Dans Swift 4.2 et Xcode 10

if UIDevice().userInterfaceIdiom == .phone {
    //This is iPhone
} else if UIDevice().userInterfaceIdiom == .pad { 
    //This is iPad
} else if UIDevice().userInterfaceIdiom == .tv {
    //This is Apple TV
}

Si vous souhaitez détecter un appareil spécifique

let screenHeight = UIScreen.main.bounds.size.height
if UIDevice().userInterfaceIdiom == .phone {
    if (screenHeight >= 667) {
        print("iPhone 6 and later")
    } else if (screenHeight == 568) {
        print("SE, 5C, 5S")
    } else if(screenHeight<=480){
        print("4S")
    }
} else if UIDevice().userInterfaceIdiom == .pad { 
    //This is iPad
}

Pourquoi si compliqué? C'est comme ça que je le fais ...

Swift 4:

var iPad : Bool {
    return UIDevice.current.model.contains("iPad")
}

De cette façon, vous pouvez simplement dire if iPad {}

Pour les dernières versions d'iOS, ajoutez simplement UITraitCollection:

extension UITraitCollection {

    var isIpad: Bool {
        return horizontalSizeClass == .regular && verticalSizeClass == .regular
    }
}

puis dans UIViewControllerjuste vérifier:

if traitCollection.isIpad { ... }

if(UI_USER_INTERFACE_IDIOM () == UIUserInterfaceIdiom.pad)
 {
            print("This is iPad")
 }else if (UI_USER_INTERFACE_IDIOM () == UIUserInterfaceIdiom.phone)
 {
            print("This is iPhone");
  }