web-dev-qa-db-fra.com

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

Comment puis-je détecter le tout premier lancement de

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  // if very first launch than perform actionA
  // else perform actionB
}

méthode?

iosiphonelaunchlaunching-application
158
iscavengers
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    if (![[NSUserDefaults standardUserDefaults] boolForKey:@"HasLaunchedOnce"])
    {
        [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"HasLaunchedOnce"];
        [[NSUserDefaults standardUserDefaults] synchronize];
    }
    return YES;
}
380
user529758

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 essayez ceci,

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

UPDATE: - Pour OBJ-C , je l'utilise,

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

Réf. Pour OBJ-C: https://stackoverflow.com/a/9964400/3411787

34
Zaid Pathan

J'ai écrit une petite bibliothèque à cette fin. Cela me permet de savoir s'il s'agit du tout premier lancement, ou juste pour cette version, et de toutes les versions antérieures installées par l'utilisateur. Il est disponible sur github en tant que cocoapode sous la licence Apache 2: GBVersionTracking

Vous appelez juste cela dans application:didFinishLaunching:withOptions:

[GBVersionTracking track];

Et ensuite, pour vérifier s'il s'agit du premier lancement, appelez-le n'importe où:

[GBVersionTracking isFirstLaunchEver];

Et pareillement:

[GBVersionTracking isFirstLaunchForVersion];

[GBVersionTracking currentVersion];
[GBVersionTracking previousVersion];
[GBVersionTracking versionHistory];
32
lms

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 d'UIApplication comme celle-ci:

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
}
8
dennis-tra

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;
}
8
Mati Bot

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

alors dans votre code

UIApplication.isFirstLaunch()
7
KIO

Vous devez enregistrer quelque chose lorsque vous lancez votre ordinateur, puis vérifiez s'il existe. Sinon, c'est la première fois. "Quelque chose" peut être un fichier, une entrée de base de données, un paramètre dans les valeurs par défaut de l'utilisateur ....

5
Phillip Mills

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

Il sera utile d’ajouter ce code dans vos préférences de lancement d’application ou ailleurs, vous devrez peut-être vérifier si c’est la première fois que votre application est 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. Ne pas utiliser de bools dans les préférences Il suffit de s'en tenir à des entiers. Ils par défaut à zéro lorsqu'ils ne sont pas définis.

Également [theDefaults synchronize]; _ line n'est pas obligatoire, mais j'ai constaté 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. De plus, il s'agit d'une meilleure pratique.

4
Milo

enregistrez une clé bool dans NSUserDefaults pour la première fois, ce sera non, vous la changerez en oui et vous la conserverez ainsi jusqu'à la suppression ou la réinstallation de l'application, ce sera encore la première fois.

3
Malek_Jundi

Pour Swift 2.0 dans Xcode 7. Dans le fichier AppDelegate.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
    }
}

}
3
MB_iOSDeveloper

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;
}
2
Chris Fremgen

Voici une réponse à utiliser dans Swift 5.0. L'amélioration par rapport à @Zaid Pathan est qu'il n'y a pas de contrat caché. Si vous n'appelez pas setFirstAppLaunch() exactement - ne fois avant d'appeler isFirstAppLaunch(), vous obtiendrez une erreur d'assertion (uniquement en mode débogage).

fileprivate struct _firstAppLaunchStaticData {
    static var alreadyCalled = false
    static var isFirstAppLaunch = true
    static let appAlreadyLaunchedString = "__private__appAlreadyLaunchedOnce"
}

func setFirstAppLaunch() {
    assert(_firstAppLaunchStaticData.alreadyCalled == false, "[Error] You called setFirstAppLaunch more than once")
    _firstAppLaunchStaticData.alreadyCalled = true
    let defaults = UserDefaults.standard

    if defaults.string(forKey: _firstAppLaunchStaticData.appAlreadyLaunchedString) != nil {
        _firstAppLaunchStaticData.isFirstAppLaunch = false
    }
    defaults.set(true, forKey: _firstAppLaunchStaticData.appAlreadyLaunchedString)
}

func isFirstAppLaunch() -> Bool {
    assert(_firstAppLaunchStaticData.alreadyCalled == true, "[Error] Function setFirstAppLaunch wasn't called")
    return _firstAppLaunchStaticData.isFirstAppLaunch
}

Ensuite, il vous suffit d'appeler la fonction setFirstAppLaunch() au début de votre application et isFirstAppLaunch() à chaque fois que vous souhaitez vérifier si votre application a été appelée.

0
aeon

NSUserDefaults + Macro

La meilleure approche consiste à utiliser NSUserDefaults et à enregistrer une variable BOOL. Comme mentionné ci-dessus, le code suivant fera l'affaire:

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

Vous pouvez également créer une macro comme ci-dessous pour vérifier facilement s’il s’agit du premier lancement ou non.

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

Alors utilisez-le comme tel,

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

Swift

struct Pref {
    static let keyFirstRun = "PrefFirstRun"
    static var isFirstRun: Bool {
        get {
            return UserDefaults.standard.bool(forKey: keyFirstRun)
        }
        set {
            UserDefaults.standard.set(newValue, forKey: keyFirstRun)
        }
    }
}

Enregistrez les valeurs par défaut au lancement de l'application:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        let prefs: [String:Any] = [
            Pref.keyFirstRun: true
            ...
        ]

        UserDefaults.standard.register(defaults: prefs)

Valeur claire lors de la fermeture de l'application:

func applicationWillTerminate(_ application: UIApplication) {
        Pref.isFirstRun = false

Vérifier la valeur:

 if Pref.isFirstRun {
    ... do whatever
0
Prcela