¿Cómo puedo detectar el primer tiempo de lanzamiento de

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

método?

InformationsquelleAutor iscavengers | 2012-04-01

14 Comentarios

  1. 381
    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
    {
        if (![[NSUserDefaults standardUserDefaults] boolForKey:@"HasLaunchedOnce"])
        {
            [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"HasLaunchedOnce"];
            [[NSUserDefaults standardUserDefaults] synchronize];
        }
        return YES;
    }
    • Este no es trabajo para mí en iOS 7.0.4
    • Lo que debería.
    • Me sale un error debido a que el método no devuelve un valor booleano. Si yo uso return 0; para matar el error se produce un error.
    • 1. ??? Devuelve BOOL. 2. A continuación, el error está en tu código… si devuelve 0 hace de este accidente, entonces algo está terriblemente mal — en otros lugares.
    • De nuevo, ¿por qué downvote esto sin explicación?
    • no NSUserDefaults un lugar común? lo que si hay otra aplicación que utiliza la misma «clave» que estoy usando?
    • No, los valores predeterminados del usuario se almacenan en una lista de propiedades por sandbox (=por aplicación) base.
    • El amor esta solución.Gracias.
    • Hay una API para establecer un valor predeterminado para NSUserDefaults: developer.apple.com/library/ios/documentation/Cocoa/Reference/…:
    • la solución perfecta
    • Se trabajará sólo para nuevas aplicaciones que nunca se presentó antes.
    • Creo que esto no funcionará si la aplicación de la actualización
    • Elad: puede versión claves si quieres… funciona perfectamente

  2. 35

    En Swift 3, 4 intente esto:

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

    En Swift 2 probar este,

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

    ACTUALIZACIÓN:- Para OBJ-C yo uso este,

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

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

  3. 32

    Escribí una pequeña biblioteca para este mismo propósito. Me permite saber si este es el primer lanzamiento nunca, o sólo para esta versión, y cualquiera de las versiones anteriores que el usuario ha instalado. Está disponible en github como un cocoapod bajo la licencia Apache 2: GBVersionTracking

    Usted acaba de llamar este en application:didFinishLaunching:withOptions:

    [GBVersionTracking track];

    Y, a continuación, para comprobar si este es el primer lanzamiento a llamar a este lugar:

    [GBVersionTracking isFirstLaunchEver];

    Y de manera similar:

    [GBVersionTracking isFirstLaunchForVersion];
    
    [GBVersionTracking currentVersion];
    [GBVersionTracking previousVersion];
    [GBVersionTracking versionHistory];
    • Esto es casi perfecto! Habría sido impresionante, sin la GBToolbox de dependencia y un podspec.
    • GBToolbox de dependencia se ha ido, y la biblioteca viene con un podspec (publicado a CocoaPods especificaciones de la repo).
  4. 8

    Otra idea para Xcode 7 y Swift 2.0 es el uso de extensiones de

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

    Ahora puede escribir en cualquier lugar en su aplicación

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

    Yo personalmente prefiero una extensión de UIApplication como este:

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

    Porque la llamada a la función es más descriptivo:

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

    Puede implementar con el método estático a continuación:

    + (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;
    }
    • tenga en cuenta que usted necesita para bloquear este método si usted desea ser seguro para subprocesos.
    • El NSUserDefaults clase es thread-safe.
    • Lo sé, pero este método no lo es. 2 Hilos puede llegar a la si(!la bandera){ cuando la bandera es NO. que se obtendrá dentro de la si los bloques. uno de ellos va a llegar a el interior de la persona y del conjunto de la NSUserDefaults y el segundo pasar el «hasLaunchOnce» (debido a que el primer hilo declarado) y ajustar el resultado a NO. Eso significa que usted puede obtener el valor incorrecto.
  6. 7

    para swift 3.0

    agregar extensión

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

    a continuación, en el código

    UIApplication.isFirstLaunch()
  7. 5

    Necesita guardar algo cuando se inicia y, a continuación, comprobar para ver si existe. Si no, es la primera vez. «Algo» puede ser un archivo, una base de datos de entrada, un ajuste en los valores predeterminados del usuario….

  8. 4

    Es bastante simple de hacer esto y sólo requiere de seis líneas de código.

    Será útil para añadir este código en el inicio de la aplicación de preferencias o cualquier otra cosa que usted puede ser que necesite para probar si o no, es la primera vez que su solicitud ha sido ejecutar.

    //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. NO utilice bools en las preferencias de Sólo se adhieren a los números enteros. El valor predeterminado de cero cuando indefinido.

    También, la [theDefaults synchronize]; línea no es necesaria, pero he encontrado que cuando una aplicación se ejecutó cientos de veces en cientos de dispositivos, los resultados no siempre son fiables, además, es una mejor práctica.

    • Tu ejemplo funciona, pero todo el OP pregunta es si es la primera vez que inicie o no. Un bool está perfectamente bien para esto. El código tiene sentido si uno quiere saber el número de veces que el usuario abre la aplicación.
  9. 3

    almacenar un bool clave en NSUserDefaults primera vez no se va a cambiar lo que sí y manténgalo así hasta que la aplicación de eliminar o volver a instalar será de nuevo tha primera vez.

  10. 3

    Para Swift 2.0 en Xcode 7.
    En el AppDelegate.swift archivo:

    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
        }
    }
    
    }
  11. 2

    Fácil y rápida de la función

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

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

    Registrar valores por defecto en el inicio de la aplicación:

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    
            let prefs: [String:Any] = [
                Pref.keyFirstRun: true
                ...
            ]
    
            UserDefaults.standard.register(defaults: prefs)

    Valor claro en la aplicación de la terminación:

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

    El valor de verificación:

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

    NSUserDefaults + Macro

    El mejor enfoque es utilizar NSUserDefaults y guardar un BOOL variable.
    Como se mencionó anteriormente, el código siguiente bien:

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

    También puede crear un macro como de abajo para comprobar fácilmente si es la primera vez que se inicie o no

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

    A continuación, utilizarlo como tal,

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

    Aquí es una respuesta de trabajo en swift 5.0. La mejora en comparación con @Zaid Pathan la respuesta es que no hay oculto contrato. Si usted no llama a setFirstAppLaunch() exactamente una vez antes de llamar a isFirstAppLaunch() obtendrá un error de aserción (sólo en modo de depuración).

    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
    }

    A continuación, sólo tiene que llamar a la función setFirstAppLaunch() en el inicio de su aplicación y isFirstAppLaunch() cuando desea comprobar si su aplicación ha sido llamado.

Dejar respuesta

Please enter your comment!
Please enter your name here