Как обнаружить первый запуск приложения на iPhone

Как я могу обнаружить самый первый запуск

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

метод?

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

В Swift 3, 4 попробуйте это:

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

В Swift 2 попробуйте это,

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

ОБНОВЛЕНИЕ: - Для OBJ-C я использую это,

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

Ссылка для OBJ-C: https://stackoverflow.com/a/9964400/3411787

Я написал крошечную библиотеку для этой цели. Это позволяет мне узнать, является ли это первым запуском в истории, или только для этой версии, и любых предыдущих версий, которые установил пользователь. Он доступен на github как cocoapod под лицензией Apache 2: GBVersionTracking

Вы просто называете это в application:didFinishLaunching:withOptions:

[GBVersionTracking track];

А затем, чтобы проверить, является ли это первым запуском, просто вызовите это где-нибудь:

[GBVersionTracking isFirstLaunchEver];

И так же:

[GBVersionTracking isFirstLaunchForVersion];

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

для Swift 3.0 - Swift 5

добавить расширение

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

тогда в вашем коде

UIApplication.isFirstLaunch()

Другая идея для Xcode 7 и Swift 2.0 - использовать расширения

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

Теперь вы можете написать в любом месте вашего приложения

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

Я лично предпочитаю расширение UIApplication следующим образом:

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

Поскольку вызов функции является более наглядным:

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

Вы можете реализовать это статическим методом ниже:

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

Вам нужно что-то сохранить при запуске, а затем проверить, существует ли оно. Если нет, то это первый раз. «Нечто» может быть файлом, записью в базе данных, настройкой по умолчанию для пользователя ....

Это довольно просто сделать и требует всего шесть строк кода.

Было бы полезно добавить этот код в настройках запуска вашего приложения или в любом другом месте, где вам может понадобиться проверить, работает ли приложение в первый раз или нет.

//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 НЕ используйте bools в настройках Просто придерживайтесь целых чисел. Они по умолчанию равны нулю, когда не определены.

Кроме того, [theDefaults synchronize];линия не обязательна, но я обнаружил, что когда приложение запускается сотни раз на сотнях устройств, результаты не всегда надежны, кроме того, это более эффективная практика.

сохраните ключ bool в NSUserDefaults в первый раз, если вы не измените его на да и оставьте так до тех пор, пока приложение не удалит или не переустановит его снова в первый раз.

Быстрая и простая функция

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

Для Swift 2.0 в Xcode 7. В файле 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
    }
}

}

быстрый

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

Зарегистрируйте значения по умолчанию при запуске приложения:

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

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

        UserDefaults.standard.register(defaults: prefs)

Очистить значение при завершении приложения:

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

Проверьте значение:

 if Pref.isFirstRun {
    ... do whatever 

В быстром я бы предложил использовать глобальную константу, которая может быть очень легко сделана вне любой области, такой как над делегатом приложения. Таким образом, он будет установлен на правильное значение до тех пор, пока приложение не будет завершено. оно все равно вернет то же значение, если приложение перейдет в фоновый режим или около того. значение изменится, только если приложение будет полностью перезапущено.

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

Но, честно говоря, лучше отследить тот факт, что приложение было отправлено в фоновом режиме хотя бы один раз. В таком случае я предпочитаю использовать расширение для UIApplication и установить флаг в методе applicationDidEnterBackground так, чтобы:

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

а затем в вашем приложении делегат или делегат сцены

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

Swift 5 iOS 13.

Мне нравится быстро и легко Крис Фремген . Я обновил его.

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

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

}

Обновлено для 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
}

Тогда вы называете это как

UIApplication.isFirstLaunch()

NSUserDefaults + Macro

Наилучшим подходом является использование NSUserDefaultsи сохранение BOOLпеременной. Как уже упоминалось выше, следующий код будет хорошо работать:

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

Вы также можете создать макрос, как показано ниже, чтобы легко проверить, является ли он первым запуском или нет

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

Тогда используйте это как таковое,

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

Вот ответ, работающий в Swift 5.0. Улучшение по сравнению с ответом @Zaid Pathan в том, что нет скрытого контракта. Если вы не позвоните setFirstAppLaunch()ровно один раз перед вызовом, isFirstAppLaunch()вы получите ошибку подтверждения (только в режиме отладки).

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
}

Затем вам просто нужно вызвать функцию setFirstAppLaunch()в начале вашего приложения и isFirstAppLaunch()всякий раз, когда вы хотите проверить, было ли вызвано ваше приложение.