Comment vérifier la version iOS?

Question

Je souhaite vérifier si la version iOS du périphérique est supérieure à 3.1.3 J'ai essayé des solutions telles que:

[[UIDevice currentDevice].systemVersion floatValue]

mais ça ne marche pas, je veux juste un:

if (version > 3.1.3) { }

Comment puis-je atteindre cet objectif?

Answer 1

La réponse rapide…

À partir de Swift 2.0, vous pouvez utiliser #available dans une if ou guard pour protéger le code qui ne doit être exécuté que sur certains systèmes.

if #available(iOS 9, *) {}


En Objective-C, vous devez vérifier la version du système et effectuer une comparaison.

[[NSProcessInfo processInfo] operatingSystemVersion] sous iOS 8 et supérieur.

À partir de Xcode 9:

if (@available(iOS 9, *)) {}

La réponse complète…

Dans Objective-C, et Swift dans de rares cas, il est préférable d'éviter de se fier à la version du système d'exploitation pour indiquer les capacités du périphérique ou du système d'exploitation. Il existe généralement une méthode plus fiable pour vérifier si une fonctionnalité ou une classe particulière est disponible.

Vérification de la présence d'API:

Par exemple, vous pouvez vérifier si UIPopoverController est disponible sur le périphérique actuel à l'aide de NSClassFromString:

if (NSClassFromString(@"UIPopoverController")) {
    // Do something
}

Pour les classes faiblement liées, vous pouvez envoyer un message directement à la classe. Notamment, cela fonctionne pour les frameworks qui ne sont pas explicitement liés en tant que "Required". Pour les classes manquantes, l'expression est évaluée à zéro, en échouant la condition:

if ([LAContext class]) {
    // Do something
}

Certaines classes, telles que CLLocationManager et UIDevice, fournissent des méthodes pour vérifier les capacités du périphérique:

if ([CLLocationManager headingAvailable]) {
    // Do something
}

Vérification de la présence de symboles:

Très occasionnellement, vous devez vérifier la présence d'une constante. Cela est arrivé dans iOS 8 avec l'introduction de UIApplicationOpenSettingsURLString, utilisé pour charger l'application Paramètres via -openURL:. La valeur n'existait pas avant iOS 8. Si vous passez nil à cette API, vous devez vous assurer de vérifier l'existence de la constante:

if (&UIApplicationOpenSettingsURLString != NULL) {
    [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
}

Comparaison avec la version du système d'exploitation:

Supposons que vous soyez confronté au besoin relativement rare de vérifier la version du système d'exploitation. NSProcessInfo inclut une méthode permettant d'effectuer des comparaisons de version avec moins de risque d'erreur:

- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version

Les projets ciblant des systèmes plus anciens peuvent utiliser systemVersion sur UIDevice. Apple l'utilise dans leur exemple de code GLSprite .

// A system version of 3.1 or greater is required to use CADisplayLink. The NSTimer
// class is used as fallback when it isn't available.
NSString *reqSysVer = @"3.1";
NSString *currSysVer = [[UIDevice currentDevice] systemVersion];
if ([currSysVer compare:reqSysVer options:NSNumericSearch] != NSOrderedAscending) {
    displayLinkSupported = TRUE;
}

Si, pour une raison quelconque, vous décidez que systemVersion est ce que vous voulez, assurez-vous de le traiter comme une chaîne, sinon vous risquez de tronquer le numéro de révision du correctif (par exemple, 3.1.2 -> 3.1).

Answer 2

/*
 *  System Versioning Preprocessor Macros
 */ 

#define SYSTEM_VERSION_EQUAL_TO(v)                  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedSame)
#define SYSTEM_VERSION_GREATER_THAN(v)              ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedDescending)
#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
#define SYSTEM_VERSION_LESS_THAN(v)                 ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)
#define SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v)     ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedDescending)

/*
 *  Usage
 */ 

if (SYSTEM_VERSION_LESS_THAN(@"4.0")) {
    ...
}

if (SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"3.1.1")) {
    ...
}

Answer 3

Comme suggéré par le officiel Apple docs : vous pouvez utiliser le NSFoundationVersionNumber du fichier d’en-tête NSObjCRuntime.h.

if (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1) {
    // here you go with iOS 7
}

Answer 4

À partir de Xcode 9, dans Objective-C: 

if (@available(iOS 11, *)) {
    // iOS 11 (or newer) ObjC code
} else {
    // iOS 10 or older code
}

À partir de Xcode 7, dans Swift: 

if #available(iOS 11, *) {
    // iOS 11 (or newer) Swift code
} else {
    // iOS 10 or older code
}

---

Pour la version, vous pouvez spécifier le MAJOR, le MINOR ou le PATCH (voir http://semver.org/ pour les définitions). Exemples:

• iOS 11 et iOS 11.0 sont la même version minimale
• iOS 10, iOS 10.3, iOS 10.3.1 sont différentes versions minimales

Vous pouvez entrer des valeurs pour n'importe lequel de ces systèmes:

• iOS, macOS, watchOS, tvOS

Exemple de cas réel tiré de un de mes pods :

if #available(iOS 10.0, tvOS 10.0, *) {
    // iOS 10+ and tvOS 10+ Swift code
} else {
    // iOS 9 and tvOS 9 older code
}

---

Documentation

Answer 5

Ceci est utilisé pour vérifier la version de SDK compatible dans Xcode, ceci si vous avez une grande équipe avec différentes versions de Xcode ou plusieurs projets prenant en charge différents SDK partageant le même code:

#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000
  //programming in iOS 8+ SDK here
#else
  //programming in lower than iOS 8 here   
#endif

Ce que vous voulez vraiment, c'est vérifier la version iOS sur l'appareil. Vous pouvez le faire avec ceci:

if ([[[UIDevice currentDevice] systemVersion] floatValue] < 8.0) {
  //older than iOS 8 code here
} else {
  //iOS 8 specific code here
}

Version rapide:

if let version = Float(UIDevice.current.systemVersion), version < 9.3 {
    //add lower than 9.3 code here
} else {
    //add 9.3 and above code here
}

Les versions actuelles de Swift devraient utiliser ceci:

if #available(iOS 12, *) {
    //iOS 12 specific code here
} else {
    //older than iOS 12 code here
}

Answer 6

Essayer:

NSComparisonResult order = [[UIDevice currentDevice].systemVersion compare: @"3.1.3" options: NSNumericSearch];
if (order == NSOrderedSame || order == NSOrderedDescending) {
    // OS version >= 3.1.3
} else {
    // OS version < 3.1.3
}

Answer 7

Approche préférée

Dans Swift 2.0, Apple a ajouté une vérification de la disponibilité à l’aide d’une syntaxe beaucoup plus pratique (En savoir plus ici ). Maintenant, vous pouvez vérifier la version du système d'exploitation avec une syntaxe plus propre:

if #available(iOS 9, *) {
    // Then we are on iOS 9
} else {
    // iOS 8 or earlier
}

Ceci est préférable à la vérification de respondsToSelector etc. ( Nouveautés de Swift ). Maintenant, le compilateur vous avertira toujours si vous ne gardez pas votre code correctement.

---

Pre Swift 2.0

La nouveauté dans iOS 8 est NSProcessInfo, ce qui permet de mieux contrôler les versions sémantiques.

Déploiement sur iOS 8 et supérieur

Pour les cibles de déploiement minimales de iOS 8.0 ou supérieures, utilisez NSProcessInfooperatingSystemVersion ou isOperatingSystemAtLeastVersion. 

Cela donnerait ce qui suit:

let minimumVersion = NSOperatingSystemVersion(majorVersion: 8, minorVersion: 1, patchVersion: 2)
if NSProcessInfo().isOperatingSystemAtLeastVersion(minimumVersion) {
    //current version is >= (8.1.2)
} else {
    //current version is < (8.1.2)
}

Déploiement sur iOS 7

Pour les cibles de déploiement minimales de iOS 7.1 ou inférieures, utilisez la comparaison avec NSStringCompareOptions.NumericSearch sur UIDevice systemVersion.

Cela donnerait:

let minimumVersionString = "3.1.3"
let versionComparison = UIDevice.currentDevice().systemVersion.compare(minimumVersionString, options: .NumericSearch)
switch versionComparison {
    case .OrderedSame, .OrderedDescending:
        //current version is >= (3.1.3)
        break
    case .OrderedAscending:
        //current version is < (3.1.3)
        fallthrough
    default:
        break;
}

Plus de lecture à NSHipster .

Answer 8

Je recommande: 

if ([[[UIDevice currentDevice] systemVersion] floatValue] > 3.13) {
    ; // ...
}

crédit: Comment cibler une version spécifique de l'iPhone?

Answer 9

Je les garde toujours dans mon fichier Constants.h:

#define IS_IPHONE5 (([[UIScreen mainScreen] bounds].size.height-568)?NO:YES) 
#define IS_OS_5_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 5.0)
#define IS_OS_6_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 6.0)
#define IS_OS_7_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0)
#define IS_OS_8_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 8.0)

Answer 10

+(BOOL)doesSystemVersionMeetRequirement:(NSString *)minRequirement{

// eg  NSString *reqSysVer = @"4.0";


  NSString *currSysVer = [[UIDevice currentDevice] systemVersion];

  if ([currSysVer compare:minRequirement options:NSNumericSearch] != NSOrderedAscending)
  {
    return YES;
  }else{
    return NO;
  }


}

Answer 11

Avec la classe Version contenue dans nv-ios-version project (licence Apache, version 2.0), il est facile d'obtenir et de comparer la version d'iOS. Un exemple de code ci-dessous affiche la version iOS et vérifie si la version est supérieure ou égale à 6.0.

// Get the system version of iOS at runtime.
NSString *versionString = [[UIDevice currentDevice] systemVersion];

// Convert the version string to a Version instance.
Version *version = [Version versionWithString:versionString];

// Dump the major, minor and micro version numbers.
NSLog(@"version = [%d, %d, %d]",
    version.major, version.minor, version.micro);

// Check whether the version is greater than or equal to 6.0.
if ([version isGreaterThanOrEqualToMajor:6 minor:0])
{
    // The iOS version is greater than or equal to 6.0.
}

// Another way to check whether iOS version is
// greater than or equal to 6.0.
if (6 <= version.major)
{
    // The iOS version is greater than or equal to 6.0.
}

Project Page: nv-ios-version
TakahikoKawasaki/nv-ios-version

Blog: Obtenir et comparer la version d'iOS au moment de l'exécution avec la classe de version
Obtenir et comparer la version d'iOS au moment de l'exécution avec la classe de version

Answer 12

Nouveau moyen de vérifier la version du système à l'aide de la méthode systemVersion [[UIDevice currentDevice]] et NSFoundationVersionNumber de Swift Forget.

Nous pouvons utiliser NSProcessInfo -isOperatingSystemAtLeastVersion

     import Foundation

     let yosemite = NSOperatingSystemVersion(majorVersion: 10, minorVersion: 10, patchVersion: 0)
     NSProcessInfo().isOperatingSystemAtLeastVersion(yosemite) // false

Answer 13

UIDevice + IOSVersion.h

@interface UIDevice (IOSVersion)

+ (BOOL)isCurrentIOSVersionEqualToVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionGreaterThanVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionGreaterThanOrEqualToVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionLessThanVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionLessThanOrEqualToVersion:(NSString *)iOSVersion

@end

UIDevice + IOSVersion.m

#import "UIDevice+IOSVersion.h"

@implementation UIDevice (IOSVersion)

+ (BOOL)isCurrentIOSVersionEqualToVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] == NSOrderedSame;
}

+ (BOOL)isCurrentIOSVersionGreaterThanVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] == NSOrderedDescending;
}

+ (BOOL)isCurrentIOSVersionGreaterThanOrEqualToVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] != NSOrderedAscending;
}

+ (BOOL)isCurrentIOSVersionLessThanVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] == NSOrderedAscending;
}

+ (BOOL)isCurrentIOSVersionLessThanOrEqualToVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] != NSOrderedDescending;
}

@end

Answer 14

if (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1) {
        // Your code here
}

Bien entendu, NSFoundationVersionNumber_iOS_6_1 doit être remplacé par applicable pour la version iOS que vous souhaitez vérifier. Ce que je viens d'écrire sera probablement beaucoup utilisé pour tester si un appareil utilise iOS7 ou une version précédente.

Answer 15

un peu tard pour la fête, mais à la lumière d'iOS 8.0, cela pourrait être pertinent:

si vous pouvez éviter d'utiliser 

[[UIDevice currentDevice] systemVersion]

Au lieu de cela, vérifiez l'existence d'une méthode/classe/quoi que ce soit d'autre.

if ([self.yourClassInstance respondsToSelector:@selector(<yourMethod>)]) 
{ 
    //do stuff 
}

Je l’ai trouvée utile pour le gestionnaire d’emplacement où je dois appeler requestWhenInUseAuthorization pour iOS 8.0 mais la méthode n’est pas disponible pour iOS <8.

Answer 16

En général, il est préférable de demander si un objet peut effectuer un sélecteur donné, plutôt que de vérifier un numéro de version pour décider s'il doit être présent.

Lorsque ce n'est pas une option, vous devez être prudent ici car [@"5.0" compare:@"5" options:NSNumericSearch] renvoie NSOrderedDescending, ce qui pourrait ne pas être du tout voulu; Je pourrais m'attendre à NSOrderedSame ici. C’est au moins une préoccupation théorique à laquelle, selon moi, il vaut la peine de se défendre.

Il est également intéressant d’envisager la possibilité d’une mauvaise entrée de version à laquelle on ne peut raisonnablement pas comparer. Apple fournit les trois constantes prédéfinies NSOrderedAscending, NSOrderedSame et NSOrderedDescending, mais je peux penser à une utilisation de quelque chose appelé NSOrderedUnordered dans l'éventualité où je ne pourrais pas comparer deux choses et je voudrais renvoyer une valeur l'indiquant.

De plus, il n'est pas impossible qu'Apple développe un jour ses trois constantes prédéfinies pour permettre diverses valeurs de retour, rendant ainsi la comparaison != NSOrderedAscending peu judicieuse.

Cela dit, considérons le code suivant.

typedef enum {kSKOrderedNotOrdered = -2, kSKOrderedAscending = -1, kSKOrderedSame = 0, kSKOrderedDescending = 1} SKComparisonResult;

@interface SKComparator : NSObject
+ (SKComparisonResult)comparePointSeparatedVersionNumber:(NSString *)vOne withPointSeparatedVersionNumber:(NSString *)vTwo;
@end

@implementation SKComparator
+ (SKComparisonResult)comparePointSeparatedVersionNumber:(NSString *)vOne withPointSeparatedVersionNumber:(NSString *)vTwo {
  if (!vOne || !vTwo || [vOne length] < 1 || [vTwo length] < 1 || [vOne rangeOfString:@".."].location != NSNotFound ||
    [vTwo rangeOfString:@".."].location != NSNotFound) {
    return SKOrderedNotOrdered;
  }
  NSCharacterSet *numericalCharSet = [NSCharacterSet characterSetWithCharactersInString:@".0123456789"];
  NSString *vOneTrimmed = [vOne stringByTrimmingCharactersInSet:numericalCharSet];
  NSString *vTwoTrimmed = [vTwo stringByTrimmingCharactersInSet:numericalCharSet];
  if ([vOneTrimmed length] > 0 || [vTwoTrimmed length] > 0) {
    return SKOrderedNotOrdered;
  }
  NSArray *vOneArray = [vOne componentsSeparatedByString:@"."];
  NSArray *vTwoArray = [vTwo componentsSeparatedByString:@"."];
  for (NSUInteger i = 0; i < MIN([vOneArray count], [vTwoArray count]); i++) {
    NSInteger vOneInt = [[vOneArray objectAtIndex:i] intValue];
    NSInteger vTwoInt = [[vTwoArray objectAtIndex:i] intValue];
    if (vOneInt > vTwoInt) {
      return kSKOrderedDescending;
    } else if (vOneInt < vTwoInt) {
      return kSKOrderedAscending;
    }
  }
  if ([vOneArray count] > [vTwoArray count]) {
    for (NSUInteger i = [vTwoArray count]; i < [vOneArray count]; i++) {
      if ([[vOneArray objectAtIndex:i] intValue] > 0) {
        return kSKOrderedDescending;
      }
    }
  } else if ([vOneArray count] < [vTwoArray count]) {
    for (NSUInteger i = [vOneArray count]; i < [vTwoArray count]; i++) {
      if ([[vTwoArray objectAtIndex:i] intValue] > 0) {
        return kSKOrderedAscending;
      }
    }
  }
  return kSKOrderedSame;
}
@end

Answer 17

#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)

Ajoutez ensuite une condition if comme suit: -

if(SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"10.0")) {
   //Your code
}       

Answer 18

#define _kisiOS7 ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0)

if (_kisiOS7) {
            NSLog(@"iOS7 or greater")
} 
else {
           NSLog(@"Less than iOS7");
}

Answer 19

Essayez le code ci-dessous:

NSString *versionString = [[UIDevice currentDevice] systemVersion];

Answer 20

Il existe des versions comme 7.0 ou 6.0.3, de sorte que nous pouvons simplement convertir la version en numérique pour la comparer. si la version ressemble à la version 7.0, ajoutez-y simplement un autre ".0", puis prenez sa valeur numérique.

 int version;
 NSString* iosVersion=[[UIDevice currentDevice] systemVersion];
 NSArray* components=[iosVersion componentsSeparatedByString:@"."];
 if ([components count]==2) {
    iosVersion=[NSString stringWithFormat:@"%@.0",iosVersion];

 }
 iosVersion=[iosVersion stringByReplacingOccurrencesOfString:@"." withString:@""];
 version=[iosVersion integerValue];

Pour 6.0.0

  if (version==600) {
    // Do something
  }

pour 7.0

 if (version==700) {
   // Do something
 }

Answer 21

Juste pour récupérer la valeur de la chaîne de version du système d'exploitation:

[[UIDevice currentDevice] systemVersion]

Answer 22

#define IsIOS8 (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_7_1)

Answer 23

Je sais que c'est une vieille question, mais quelqu'un aurait dû mentionner les macros de compilation dans Availability.h. Toutes les autres méthodes présentées ici sont des solutions d'exécution et ne fonctionneront pas dans un fichier d'en-tête, une catégorie de classe ou une définition d'ivar. 

Pour ces situations, utilisez 

#if __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_6_0
  // iOS 6+ code here
#else
  // Pre iOS 6 code here
#endif

h/t this réponse

Answer 24

Utilisation de la méthode recommandée. S'il n'y a pas de définition dans les fichiers d'en-tête, vous pouvez toujours obtenir la version imprimée sur console avec un périphérique de la version IOS souhaitée.

- (BOOL) isIOS8OrAbove{
    float version802 = 1140.109985;
    float version8= 1139.100000; // there is no def like NSFoundationVersionNumber_iOS_7_1 for ios 8 yet?
    NSLog(@"la version actual es [%f]", NSFoundationVersionNumber);
    if (NSFoundationVersionNumber >= version8){
        return true;
    }
    return false;
}

Answer 25

En variante de la solution yasimturks, j'ai défini une fonction et quelques valeurs enum au lieu de cinq macros. Je le trouve plus élégant, mais c'est une question de goût.

Usage:

if (systemVersion(LessThan, @"5.0")) ...

fichier .h:

typedef enum {
  LessThan,
  LessOrEqual,
  Equal,
  GreaterOrEqual,
  GreaterThan,
  NotEqual
} Comparison;

BOOL systemVersion(Comparison test, NSString* version);

fichier .m:

BOOL systemVersion(Comparison test, NSString* version) {
  NSComparisonResult result = [[[UIDevice currentDevice] systemVersion] compare: version options: NSNumericSearch];
  switch (test) {
    case LessThan:       return result == NSOrderedAscending;
    case LessOrEqual:    return result != NSOrderedDescending;
    case Equal:          return result == NSOrderedSame;
    case GreaterOrEqual: return result != NSOrderedAscending;
    case GreaterThan:    return result == NSOrderedDescending;
    case NotEqual:       return result != NSOrderedSame;
  }
}

Vous devez ajouter le préfixe de votre application aux noms, en particulier au type Comparison.

Answer 26

Solution pour vérifier la version iOS dans Swift

switch (UIDevice.currentDevice().systemVersion.compare("8.0.0", options: NSStringCompareOptions.NumericSearch)) {
    case .OrderedAscending:
       println("iOS < 8.0")

    case .OrderedSame, .OrderedDescending:
       println("iOS >= 8.0")
}

Inconvénient de cette solution: il est simplement déconseillé de vérifier les numéros de version d’OS, quelle que soit la méthode choisie. Il ne faut jamais que les dépendances de code durs de cette manière, vérifient toujours les fonctionnalités, les capacités ou l'existence d'une classe. Considère ceci; Apple peut publier une version rétrocompatible d'une classe. Si c'est le cas, le code que vous suggérez ne l'utilisera jamais car votre logique recherche un numéro de version du système d'exploitation et NON l'existence de la classe.

( Source de cette information )

Solution pour vérifier l'existence de la classe dans Swift

if (objc_getClass("UIAlertController") == nil) {
   // iOS 7
} else {
   // iOS 8+
}

N'utilisez pas if (NSClassFromString("UIAlertController") == nil) car il fonctionne correctement sur le simulateur iOS utilisant iOS 7.1 et 8.2, mais si vous effectuez un test sur un périphérique réel utilisant iOS 7.1, vous remarquerez malheureusement que vous ne passerez jamais par le reste de l'extrait de code.

Answer 27

Essaye ça

if ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7) { 
// do some work
}

Answer 28

float deviceOSVersion = [[[UIDevice currentDevice] systemVersion] floatValue];
float versionToBeCompared = 3.1.3; //(For Example in your case)

if(deviceOSVersion < versionToBeCompared)
   //Do whatever you need to do. Device version is lesser than 3.1.3(in your case)
else 
   //Device version should be either equal to the version you specified or above

Answer 29

Une version plus générique dans Obj-C++ 11 (vous pourriez probablement remplacer certaines de ces choses par les fonctions NSString/C, mais cela est moins détaillé. Cela vous donne deux mécanismes. SplitSystemVersion vous donne un tableau de toutes les parties qui est utile si vous voulez simplement activer la version principale (par exemple, switch([self splitSystemVersion][0]) {case 4: break; case 5: break; }).

#include <boost/lexical_cast.hpp>

- (std::vector<int>) splitSystemVersion {
    std::string version = [[[UIDevice currentDevice] systemVersion] UTF8String];
    std::vector<int> versions;
    auto i = version.begin();

    while (i != version.end()) {
        auto nextIllegalChar = std::find_if(i, version.end(), [] (char c) -> bool { return !isdigit(c); } );
        std::string versionPart(i, nextIllegalChar);
        i = std::find_if(nextIllegalChar, version.end(), isdigit);

        versions.Push_back(boost::lexical_cast<int>(versionPart));
    }

    return versions;
}

/** Losslessly parse system version into a number
 * @return <0>: the version as a number,
 * @return <1>: how many numeric parts went into the composed number. e.g.
 * X.Y.Z = 3.  You need this to know how to compare again <0>
 */
- (std::Tuple<int, int>) parseSystemVersion {
    std::string version = [[[UIDevice currentDevice] systemVersion] UTF8String];
    int versionAsNumber = 0;
    int nParts = 0;

    auto i = version.begin();
    while (i != version.end()) {
        auto nextIllegalChar = std::find_if(i, version.end(), [] (char c) -> bool { return !isdigit(c); } );
        std::string versionPart(i, nextIllegalChar);
        i = std::find_if(nextIllegalChar, version.end(), isdigit);

        int part = (boost::lexical_cast<int>(versionPart));
        versionAsNumber = versionAsNumber * 100 + part;
        nParts ++;
    }

    return {versionAsNumber, nParts};
}


/** Assume that the system version will not go beyond X.Y.Z.W format.
 * @return The version string.
 */
- (int) parseSystemVersionAlt {
    std::string version = [[[UIDevice currentDevice] systemVersion] UTF8String];
    int versionAsNumber = 0;
    int nParts = 0;

    auto i = version.begin();
    while (i != version.end() && nParts < 4) {
        auto nextIllegalChar = std::find_if(i, version.end(), [] (char c) -> bool { return !isdigit(c); } );
        std::string versionPart(i, nextIllegalChar);
        i = std::find_if(nextIllegalChar, version.end(), isdigit);

        int part = (boost::lexical_cast<int>(versionPart));
        versionAsNumber = versionAsNumber * 100 + part;
        nParts ++;
    }

    // don't forget to pad as systemVersion may have less parts (i.e. X.Y).
    for (; nParts < 4; nParts++) {
        versionAsNumber *= 100;
    }

    return versionAsNumber;
}

Answer 30

Voici une version de Swift:

struct iOSVersion {
    static let SYS_VERSION_FLOAT = (UIDevice.currentDevice().systemVersion as NSString).floatValue
    static let iOS7 = (Version.SYS_VERSION_FLOAT < 8.0 && Version.SYS_VERSION_FLOAT >= 7.0)
    static let iOS8 = (Version.SYS_VERSION_FLOAT >= 8.0 && Version.SYS_VERSION_FLOAT < 9.0)
    static let iOS9 = (Version.SYS_VERSION_FLOAT >= 9.0 && Version.SYS_VERSION_FLOAT < 10.0)
}

Usage:

if iOSVersion.iOS8 {
    //Do iOS8 code here
}

Answer 31

Exemple rapide qui fonctionne réellement:

switch UIDevice.currentDevice().systemVersion.compare("8.0.0", options: NSStringCompareOptions.NumericSearch) {
case .OrderedSame, .OrderedDescending:
    println("iOS >= 8.0")
case .OrderedAscending:
    println("iOS < 8.0")
}

N'utilisez pas NSProcessInfo car il ne fonctionne pas sous 8.0, il est donc pratiquement inutile jusqu'en 2016.

Answer 32

Ajoutez le code Swift ci-dessous dans votre projet et accédez facilement aux informations telles que la version iOS et le périphérique.

class DeviceInfo: NSObject {

    struct ScreenSize
    {
        static let SCREEN_WIDTH = UIScreen.main.bounds.size.width
        static let SCREEN_HEIGHT = UIScreen.main.bounds.size.height
        static let SCREEN_MAX_LENGTH = max(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
        static let SCREEN_MIN_LENGTH = min(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
    }

    struct DeviceType
    {
        static let IS_IPHONE_4_OR_LESS =  UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH < 568.0
        static let IS_IPHONE_5 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 568.0
        static let IS_IPHONE_6 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH >= 667.0
        static let IS_IPHONE_6P = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 736.0
        static let IS_IPHONE_X = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 812.0
        static let IS_IPAD      = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1024.0
        static let IS_IPAD_PRO  = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1366.0
    }

    struct VersionType{
        static let SYS_VERSION_FLOAT = (UIDevice.current.systemVersion as NSString).floatValue
        static let iOS7 = (VersionType.SYS_VERSION_FLOAT < 8.0 && VersionType.SYS_VERSION_FLOAT >= 7.0)
        static let iOS8 = (VersionType.SYS_VERSION_FLOAT >= 8.0 && VersionType.SYS_VERSION_FLOAT < 9.0)
        static let iOS9 = (VersionType.SYS_VERSION_FLOAT >= 9.0 && VersionType.SYS_VERSION_FLOAT < 10.0)
        static let iOS10 = (VersionType.SYS_VERSION_FLOAT >= 9.0 && VersionType.SYS_VERSION_FLOAT < 11.0)
    }
}

Answer 33

Voici une version rapide des macros yasirmturk. J'espère que ça aide certains peuples

// MARK: System versionning

func SYSTEM_VERSION_EQUAL_TO(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) == NSComparisonResult.OrderedSame
}

func SYSTEM_VERSION_GREATER_THAN(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) == NSComparisonResult.OrderedDescending
}

func SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) != NSComparisonResult.OrderedAscending
}

func SYSTEM_VERSION_LESS_THAN(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) == NSComparisonResult.OrderedAscending
}

func SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) != NSComparisonResult.OrderedDescending
}

let kIsIOS7: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("7")
let kIsIOS7_1: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("7.1")
let kIsIOS8: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("8")
let kIsIOS9: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("9")