Bir iPhone'da ilk kez uygulama lansmanı nasıl tespit edilir?

İlk lansmanını nasıl tespit edebilirim?

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

yöntem?

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

In Swift 3, 4 bu deneyin:

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

In Swift 2 , bu deneyin

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

GÜNCELLEME: - For NESNE-C Bunu kullanmak,

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

OBJ-C için referans: https://stackoverflow.com/a/9964400/3411787

Bu amaçla küçük bir kütüphane yazdım. Bunun, ilk kez mi yoksa sadece bu sürüm için mi ve kullanıcının yüklediği herhangi bir önceki sürüm olup olmadığını bilmemi sağlar. Github'da Apache 2 lisansı altında bir cocoapod olarak kullanılabilir: GBVersionTracking

Buna sadece application:didFinishLaunching:withOptions:

[GBVersionTracking track];

Ve sonra bunun ilk lansman olup olmadığını kontrol etmek için bunu her yerde arayın:

[GBVersionTracking isFirstLaunchEver];

Ve benzer şekilde:

[GBVersionTracking isFirstLaunchForVersion];

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

3.0 - Swift 5 için fotoğraflar

uzantı eklemek

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

sonra kodunda

UIApplication.isFirstLaunch()

Xcode 7 ve Swift 2.0 için başka bir fikir uzantıları kullanmaktır

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

Artık uygulamanızın herhangi bir yerine yazabilirsiniz

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

Ben şahsen UIApplication bir uzantısı tercih böyle:

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

İşlev çağrısı daha açıklayıcı olduğundan:

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

Aşağıdaki statik yöntemle uygulayabilirsiniz:

+ (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;
}

Başlattığınızda bir şey kaydetmeniz ve ardından var olup olmadığını kontrol etmeniz gerekir. Değilse, ilk kez. "Bir şey" bir dosya, bir veritabanı girişi, kullanıcı varsayılan ayarları olabilir ....

Bunu yapmak oldukça basittir ve sadece altı satır kod gerektirir.

Bu kodu uygulama başlatma tercihlerinize veya uygulamanızın ilk kez çalıştırılıp çalıştırılmadığını test etmeniz gerekebilecek başka herhangi bir yere eklemek yararlı olacaktır.

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

PS Tercihlerde bools KULLANMAYIN Sadece tamsayılara sadık kalın. Tanımsız olduğunda varsayılan olarak sıfıra ayarlanırlar.

Ayrıca, [theDefaults synchronize];hat gerekli değildir, ancak bir uygulama yüzlerce cihazda yüzlerce kez çalıştırıldığında, sonuçların her zaman güvenilir olmadığını, bunun yanında daha iyi bir uygulama olduğunu keşfettim.

NSUserDefaults'ta bir bool anahtarını ilk kez saklayın, evet olmayacaksınız ve uygulamayı silinceye veya yeniden yükleyene kadar bu şekilde saklayacaksınız.

Hızlı ve kolay fonksiyon

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

Xcode 7'deki Swift 2.0 için. AppDelegate.swift dosyasında:

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

}

hızlı

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

Uygulama açılışında varsayılan değerleri kaydedin:

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

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

        UserDefaults.standard.register(defaults: prefs)

Uygulama sonlandırmasında net değer:

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

Kontrol değeri:

 if Pref.isFirstRun {
    ... do whatever 

Hızlı bir şekilde, App delegesi gibi herhangi bir kapsamın dışında çok kolay bir şekilde yapılabilen küresel bir sabit kullanmanızı öneririm. Böylece, uygulama sonlandırılmadığı sürece doğru değere ayarlanacaktır. uygulama arka plana giderse aynı değeri döndürür. değer yalnızca uygulama tamamen yeniden başlatıldığında değişir.

let isFirstLaunch: Bool = {
    if !UserDefaults.standard.bool(forKey: "hasBeenLaunchedBeforeFlag") {
        UserDefaults.standard.set(true, forKey: "hasBeenLaunchedBeforeFlag")
        UserDefaults.standard.synchronize()
        return true
    }
    return false
}()

Ancak dürüst olmak gerekirse, uygulamanın arka plana en az bir kez gönderildiğini izlemek daha iyidir. Bu durumda UIApplication üzerinde bir uzantı kullanmayı ve flag'i applicationDidEnterBackground yönteminde şöyle ayarlamayı tercih ederim:

extension UIApplication {
    private static let isFirstLaunchKey = "isFirstLaunchKey"
    static var isFirstLaunch: Bool {
        return !UserDefaults.standard.bool(forKey: isFirstLaunchKey)
    }
    static func didEnterBackground() {
        if isFirstLaunch {
            UserDefaults.standard.set(true, forKey: isFirstLaunchKey)
            UserDefaults.standard.synchronize()
        }
    }
}

ve sonra uygulama temsilcinizde veya sahne temsilcinizde

func sceneDidEnterBackground(_ scene: UIScene) {
        UIApplication.didEnterBackground()
    }

Swift 5 iOS 13.

Chris Fremgen'in hızlı ve kolay olmasını seviyorum . Bu yüzden güncelledim.

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

  if(defaults.integer(forKey: "hasRun") == 0) {
      defaults.set(1, forKey: "hasRun")
      return true
  }
  return false

}

İçin güncellenmiş XCode 11 , Swift 5

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

Sonra şöyle diyorsun

UIApplication.isFirstLaunch()

NSUserDefaults + Makro

En iyi yaklaşım NSUserDefaultsbir BOOLdeğişkeni kullanmak ve kaydetmek . Yukarıda belirtildiği gibi, aşağıdaki kod iyi olur:

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

İlk lansman olup olmadığını kolayca kontrol etmek için aşağıdaki gibi bir makro da oluşturabilirsiniz

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

Sonra böyle kullanın,

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

İşte hızlı bir 5.0 ile çalışan bir cevap. @Zaid Pathan'ın cevabına göre iyileşme, gizli bir sözleşme olmamasıdır. Aramadan önce setFirstAppLaunch()tam olarak bir kezisFirstAppLaunch() aramazsanız, bir onaylama hatası alırsınız (yalnızca hata ayıklama modunda).

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
}

Ardından setFirstAppLaunch(), uygulamanızın başlangıcında ve isFirstAppLaunch()uygulamanızın çağrılıp çağrılmadığını kontrol etmek istediğinizde işlevi çağırmanız yeterlidir .