Cách phát hiện lần đầu tiên khởi chạy ứng dụng trên iPhone

Làm thế nào tôi có thể phát hiện lần đầu tiên ra mắt

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

phương pháp?

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

Trong Swift 3, 4 hãy thử điều này:

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

Trong Swift 2 hãy thử điều này,

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

CẬP NHẬT: - Đối với OBJ-C tôi sử dụng cái này,

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

Tham chiếu cho OBJ-C: https://stackoverflow.com/a/9964400 43211787

Tôi đã viết một thư viện nhỏ cho mục đích này. Nó cho tôi biết liệu đây là lần ra mắt đầu tiên chưa từng có hay chỉ dành cho phiên bản này và mọi phiên bản trước đây mà người dùng đã cài đặt. Nó có sẵn trên github dưới dạng cocoapod theo giấy phép Apache 2: GBVersionTracking

Bạn chỉ cần gọi nó trong application:didFinishLaunching:withOptions:

[GBVersionTracking track];

Và sau đó để kiểm tra xem đây có phải là lần ra mắt đầu tiên hay không, hãy gọi nó ở bất cứ đâu:

[GBVersionTracking isFirstLaunchEver];

Và tương tự:

[GBVersionTracking isFirstLaunchForVersion];

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

cho Swift 3.0 - Swift 5

thêm phần mở rộng

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

sau đó trong mã của bạn

UIApplication.isFirstLaunch()

Một ý tưởng khác cho Xcode 7 và Swift 2.0 là sử dụng các tiện ích mở rộng

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

Bây giờ bạn có thể viết bất cứ nơi nào trong ứng dụng của bạn

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

Cá nhân tôi thích một phần mở rộng của UIApplication như thế này:

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

Bởi vì lời gọi hàm mô tả nhiều hơn:

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

Bạn có thể thực hiện nó với phương thức tĩnh bên dưới:

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

Bạn cần lưu một cái gì đó khi bạn khởi chạy và sau đó kiểm tra xem nó có tồn tại không. Nếu không, đây là lần đầu tiên. "Một cái gì đó" có thể là một tệp, mục nhập cơ sở dữ liệu, cài đặt mặc định của người dùng ....

Nó khá đơn giản để làm điều này và chỉ cần sáu dòng mã.

Sẽ rất hữu ích khi thêm mã này vào tùy chọn khởi chạy ứng dụng của bạn hoặc bất kỳ nơi nào khác mà bạn có thể cần kiểm tra xem lần đầu tiên ứng dụng của bạn có chạy hay không.

//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 KHÔNG sử dụng bool trong sở thích Chỉ cần dính vào số nguyên. Chúng mặc định là 0 khi không xác định.

Ngoài ra, [theDefaults synchronize];dòng không bắt buộc nhưng tôi thấy rằng khi một ứng dụng được chạy hàng trăm lần trên hàng trăm thiết bị, kết quả không phải lúc nào cũng đáng tin cậy, bên cạnh đó, đó là cách thực hành tốt hơn.

lưu trữ khóa bool trong NSUserDefaults lần đầu tiên, sẽ không có bạn thay đổi nó thành có và giữ nguyên như vậy cho đến khi ứng dụng xóa hoặc cài đặt lại lần đầu tiên.

Chức năng nhanh chóng và dễ dàng

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

Dành cho Swift 2.0 trong Xcode 7. Trong tệp 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
    }
}

}

nhanh

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

Đăng ký giá trị mặc định khi khởi chạy ứng dụng:

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

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

        UserDefaults.standard.register(defaults: prefs)

Xóa giá trị khi chấm dứt ứng dụng:

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

Kiểm tra giá trị:

 if Pref.isFirstRun {
    ... do whatever 

Trong swift tôi sẽ đề nghị sử dụng hằng số toàn cầu có thể được thực hiện rất dễ dàng bên ngoài bất kỳ phạm vi nào, chẳng hạn như trên đại biểu Ứng dụng. Do đó, nó sẽ được đặt thành giá trị phù hợp miễn là ứng dụng không bị chấm dứt. nó vẫn sẽ trả về cùng một giá trị nếu ứng dụng chuyển sang nền. giá trị sẽ thay đổi chỉ khi ứng dụng được khởi chạy lại hoàn toàn.

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

Nhưng thành thật mà nói, tốt hơn là theo dõi thực tế rằng ứng dụng đã được gửi đến nền ít nhất một lần. Trong trường hợp như vậy, tôi thích sử dụng tiện ích mở rộng trên UIApplication và đặt cờ trong phương thức applicationDid EntryBackground sao cho:

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

và sau đó trong đại biểu ứng dụng của bạn hoặc đại biểu cảnh

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

Swift 5 iOS 13.

Tôi thích nhanh chóng và dễ dàng bởi Chris Fremgen . Vì vậy, tôi đã cập nhật nó.

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

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

}

Đã cập nhật cho 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
}

Sau đó, bạn gọi nó là

UIApplication.isFirstLaunch()

NSUserDefaults + Macro

Cách tiếp cận tốt nhất là sử dụng NSUserDefaultsvà lưu một BOOLbiến. Như đã đề cập ở trên, đoạn mã sau sẽ hoạt động tốt:

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

Bạn cũng có thể tạo một macro như bên dưới để dễ dàng kiểm tra xem đó có phải là lần khởi chạy đầu tiên hay không

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

Sau đó sử dụng nó như vậy,

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

Đây là một câu trả lời làm việc trong swift 5.0. Sự cải thiện so với câu trả lời của @Zaid Pathan là không có hợp đồng ẩn. Nếu bạn không gọi setFirstAppLaunch()chính xác một lần trước khi gọi, isFirstAppLaunch()bạn sẽ gặp lỗi xác nhận (chỉ trong chế độ gỡ lỗi).

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
}

Sau đó, bạn chỉ cần gọi chức năng setFirstAppLaunch()khi bắt đầu ứng dụng và isFirstAppLaunch()bất cứ khi nào bạn muốn kiểm tra xem ứng dụng của bạn đã được gọi chưa.