Comment détecter le premier lancement de l'application sur un iPhone

J'ai écrit une petite bibliothèque dans ce but même. Il me permet de savoir si c'est le premier lancement jamais, ou juste pour cette version, et toutes les versions passées que l'Utilisateur a installées. Il est disponible sur github en tant que cocoapod sous la licence Apache 2: GBVersionTracking

Vous venez d'appeler ceci dans application:didFinishLaunching:withOptions:

[GBVersionTracking track];

Et puis pour vérifier si c'est le premier lancement, appelez ceci n'importe où:

[GBVersionTracking isFirstLaunchEver];

Et de même:

[GBVersionTracking isFirstLaunchForVersion];

[GBVersionTracking currentVersion];
[GBVersionTracking previousVersion];
[GBVersionTracking versionHistory];

Dans Swift 3, 4, essayez ceci:

func isAppAlreadyLaunchedOnce()->Bool{
        let defaults = UserDefaults.standard

        if let isAppAlreadyLaunchedOnce = defaults.string(forKey: "isAppAlreadyLaunchedOnce"){
            print("App already launched : \(isAppAlreadyLaunchedOnce)")
            return true
        }else{
            defaults.set(true, forKey: "isAppAlreadyLaunchedOnce")
            print("App launched first time")
            return false
        }
    }

Dans Swift 2 essayer cela,

func isAppAlreadyLaunchedOnce()->Bool{
    let defaults = NSUserDefaults.standardUserDefaults()

    if let isAppAlreadyLaunchedOnce = defaults.stringForKey("isAppAlreadyLaunchedOnce"){
        print("App already launched : \(isAppAlreadyLaunchedOnce)")
        return true
    }else{
        defaults.setBool(true, forKey: "isAppAlreadyLaunchedOnce")
        print("App launched first time")
        return false
    }
}

Mise à JOUR:- Pour OBJ-C j'utilise cela,

+ (BOOL)isAppAlreadyLaunchedOnce {
    if ([[NSUserDefaults standardUserDefaults] boolForKey:@"isAppAlreadyLaunchedOnce"])
    {
        return true;
    }
    else
    {
        [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"isAppAlreadyLaunchedOnce"];
        [[NSUserDefaults standardUserDefaults] synchronize];
        return false;
    }
}

Ref pour OBJ-C: https://stackoverflow.com/a/9964400/3411787

Une autre idée pour Xcode 7 et Swift 2.0 est d'utiliser des extensions

extension NSUserDefaults {
    func isFirstLaunch() -> Bool {
        if !NSUserDefaults.standardUserDefaults().boolForKey("HasAtLeastLaunchedOnce") {
            NSUserDefaults.standardUserDefaults().setBool(true, forKey: "HasAtLeastLaunchedOnce")
            NSUserDefaults.standardUserDefaults().synchronize()
            return true
        }
        return false
    }
}

Maintenant, vous pouvez écrire n'importe où dans votre application

if NSUserDefaults.standardUserDefaults().isFirstLaunch() {
    // do something on first launch
}

Personnellement, je préfère une extension de UIApplication comme ceci:

extension UIApplication {
    class func isFirstLaunch() -> Bool {
        if !NSUserDefaults.standardUserDefaults().boolForKey("HasAtLeastLaunchedOnce") {
            NSUserDefaults.standardUserDefaults().setBool(true, forKey: "HasAtLeastLaunchedOnce")
            NSUserDefaults.standardUserDefaults().synchronize()
            return true
        }
        return false
    }
}

Parce que l'appel de fonction est plus descriptif:

if UIApplication.isFirstLaunch() {
    // do something on first launch
}

Vous pouvez l'implémenter avec la méthode statique ci-dessous:

+ (BOOL)isFirstTime{
    static BOOL flag=NO;
    static BOOL result;

    if(!flag){
        if ([[NSUserDefaults standardUserDefaults] boolForKey:@"hasLaunchedOnce"]){
            result=NO;
        }else{
            [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"hasLaunchedOnce"];
            [[NSUserDefaults standardUserDefaults] synchronize];
            result=YES;
        }

        flag=YES;
    }
    return result;
}

Pour swift 3.0

Ajouter une extension

    extension UIApplication {
        class func isFirstLaunch() -> Bool {
            if UserDefaults.standard.bool(forKey: "hasBeenLaunchedBeforeFlag") {
                UserDefaults.standard.set(true, forKey: "hasBeenLaunchedBeforeFlag")
                UserDefaults.standard.synchronize()
                return true
            }
            return false
        }
    }

Puis dans votre code

UIApplication.isFirstLaunch()

Vous devez enregistrer quelque chose lorsque vous lancez, puis vérifier s'il existe. Si non, c'est la première fois. "Quelque chose" peut être un fichier, une base de données d'entrée, un paramètre utilisateur par défaut....

C'est assez simple à faire et ne nécessite que six lignes de code.

Il sera utile d'ajouter ce code dans les préférences de lancement de votre application ou ailleurs, vous devrez peut-être tester si c'est la première fois que votre application a été exécutée.

//These next six lines of code are the only ones required! The rest is just running      code when it's the first time.
//Declare an integer and a default.
NSUserDefaults *theDefaults;
int  launchCount;
//Set up the properties for the integer and default.
theDefaults = [NSUserDefaults standardUserDefaults];
launchCount = [theDefaults integerForKey:@"hasRun"] + 1;
[theDefaults setInteger:launchCount forKey:@"hasRun"];
[theDefaults synchronize];

//Log the amount of times the application has been run
NSLog(@"This application has been run %d amount of times", launchCount);

//Test if application is the first time running
if(launchCount == 1) {
    //Run your first launch code (Bring user to info/setup screen, etc.)
    NSLog(@"This is the first time this application has been run";
}

//Test if it has been run before
if(launchCount >= 2) {
    //Run new code if they have opened the app before (Bring user to home screen etc.
    NSLog(@"This application has been run before);
}

P.S. N'utilisez pas de bools dans les préférences respectez simplement les entiers. Ils sont par défaut à zéro lorsqu'ils sont indéfinis.

En outre, la ligne [theDefaults synchronize]; n'est pas requise mais j'ai trouvé que lorsqu'une application est exécutée des centaines de fois sur des centaines d'appareils, les résultats ne sont pas toujours fiables, d'ailleurs, c'est une meilleure pratique.

Stockez une clé bool dans NSUserDefaults la première fois que ce sera non, vous la remplacerez par oui et la conserverez comme ça jusqu'à ce que l'application supprime ou réinstalleune fois de plus.

Pour Swift 2.0 dans Xcode 7. Dans L'AppDelegate.fichier swift:

import UIKit

@UIApplicationMain

class AppDelegate: UIResponder, UIApplicationDelegate {

var window: UIWindow?

func application(application: UIApplication, willFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool
{
    return true
}


func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool
{
    didFinishLaunchingOnce()
    return true
}

func didFinishLaunchingOnce() -> Bool
{
    let defaults = NSUserDefaults.standardUserDefaults()

    if let hasBeenLauncherBefore = defaults.stringForKey("hasAppBeenLaunchedBefore")
    {
        //print(" N-th time app launched ")
        return true
    }
    else
    {
        //print(" First time app launched ")
        defaults.setBool(true, forKey: "hasAppBeenLaunchedBefore")
        return false
    }
}

}

Fonction rapide et facile

- (BOOL) isFirstTimeOpening {
    NSUserDefaults *theDefaults = [NSUserDefaults standardUserDefaults];
    if([theDefaults integerForKey:@"hasRun"] == 0) {
        [theDefaults setInteger:1 forKey:@"hasRun"];
        [theDefaults synchronize];
        return true;
    }
    return false;
}

NSUserDefaults + Macro

La meilleure approche consiste à utiliser NSUserDefaults et enregistrer une variable BOOL. Comme mentionné ci-dessus, le code suivant fera très bien:

NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
[userDefaults setObject:[NSNumber numberWithBool:true] forKey:@"~applicationHasLaunchedBefore"];
[userDefaults synchronize];

Vous pouvez également créer une macro {[11] } comme ci-dessous pour vérifier facilement s'il s'agit du premier lancement ou non

#define kApplicationHasLaunchedBefore [[NSUserDefaults standardUserDefaults] objectForKey:@"~applicationHasLaunchedBefore"]

Ensuite, utilisez-le comme tel,

if (kApplicationHasLaunchedBefore) {
    //App has previously launched
} else {
    //App has not previously launched
}