Cara mendeteksi peluncuran aplikasi pertama kali pada iPhone

Bagaimana saya bisa mendeteksi peluncuran pertama kali

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

metode?

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

Di Swift 3, 4 coba ini:

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

Di Swift 2 coba ini,

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: - Untuk OBJ-C saya menggunakan ini,

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

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

Saya menulis perpustakaan kecil untuk tujuan ini. Ini membuat saya tahu apakah ini adalah peluncuran pertama, atau hanya untuk versi ini, dan versi sebelumnya yang telah diinstal pengguna. Ini tersedia di github sebagai cocoapod di bawah lisensi Apache 2: GBVersionTracking

Anda cukup memanggil ini application:didFinishLaunching:withOptions:

[GBVersionTracking track];

Dan kemudian untuk memeriksa apakah ini adalah peluncuran pertama panggil saja ini di mana saja:

[GBVersionTracking isFirstLaunchEver];

Dan juga:

[GBVersionTracking isFirstLaunchForVersion];

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

untuk Swift 3.0 - Swift 5

tambahkan ekstensi

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

kemudian dalam kode Anda

UIApplication.isFirstLaunch()

Gagasan lain untuk Xcode 7 dan Swift 2.0 adalah menggunakan ekstensi

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

Sekarang Anda dapat menulis di mana saja di aplikasi Anda

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

Saya pribadi lebih suka perpanjangan aplikasi UIA seperti ini:

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

Karena pemanggilan fungsi lebih deskriptif:

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

Anda dapat menerapkannya dengan metode statis di bawah ini:

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

Anda perlu menyimpan sesuatu saat diluncurkan dan kemudian memeriksa untuk melihat apakah ada. Jika tidak, ini pertama kalinya. "Sesuatu" dapat berupa file, entri basis data, pengaturan di default pengguna ....

Cukup mudah untuk melakukan ini dan hanya membutuhkan enam baris kode.

Akan bermanfaat untuk menambahkan kode ini dalam preferensi peluncuran aplikasi Anda atau di mana pun Anda mungkin perlu menguji apakah ini pertama kali aplikasi Anda dijalankan.

//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 JANGAN gunakan bools di preferensi Cukup menempel bilangan bulat. Nilai standarnya ke nol saat tidak terdefinisi.

Juga, [theDefaults synchronize];garis tidak diperlukan tetapi saya telah menemukan bahwa ketika aplikasi dijalankan ratusan kali di ratusan perangkat, hasilnya tidak selalu dapat diandalkan, selain itu, itu praktik yang lebih baik.

simpan kunci bool di NSUserDefaults pertama kali itu tidak akan Anda ubah menjadi ya dan simpan seperti itu sampai aplikasi hapus atau instal kembali akan menjadi yang pertama kali.

Fungsi cepat dan mudah

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

Untuk Swift 2.0 di Xcode 7. Di file 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
    }
}

}

cepat

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

Daftarkan nilai default pada peluncuran aplikasi:

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

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

        UserDefaults.standard.register(defaults: prefs)

Nilai yang jelas pada penghentian aplikasi:

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

Periksa nilai:

 if Pref.isFirstRun {
    ... do whatever 

Dalam cepat saya akan menyarankan untuk menggunakan konstanta global yang dapat dilakukan dengan sangat mudah di luar lingkup apa pun seperti di atas delegasi App. Dengan demikian itu akan ditetapkan ke nilai yang tepat selama aplikasi tidak dihentikan. masih akan mengembalikan nilai yang sama jika aplikasi pergi ke latar belakang atau lebih. nilai akan berubah hanya jika aplikasi diluncurkan kembali seluruhnya.

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

Tapi sejujurnya lebih baik untuk melacak fakta bahwa aplikasi telah dikirim ke latar belakang setidaknya sekali. Dalam kasus seperti itu saya lebih suka menggunakan ekstensi pada aplikasi UIAp dan mengatur flag pada metode applicationDidEnterBackground sedemikian rupa sehingga:

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

dan kemudian di delegasi aplikasi Anda atau delegasi adegan

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

Swift 5 iOS 13.

Saya suka cepat dan mudah oleh Chris Fremgen . Jadi saya memperbaruinya.

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

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

}

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

Maka Anda menyebutnya sebagai

UIApplication.isFirstLaunch()

NSUserDefaults + Makro

Pendekatan terbaik adalah menggunakan NSUserDefaultsdan menyimpan BOOLvariabel. Seperti disebutkan di atas, kode berikut akan baik-baik saja:

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

Anda juga dapat membuat makro seperti di bawah ini untuk dengan mudah memeriksa apakah ini adalah peluncuran pertama atau tidak

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

Kemudian gunakan seperti itu,

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

Berikut ini jawaban yang berfungsi di swift 5.0. Peningkatan dibandingkan dengan jawaban @Zaid Pathan adalah bahwa tidak ada kontrak tersembunyi. Jika Anda tidak menelepon setFirstAppLaunch()tepat sekali sebelum menelepon isFirstAppLaunch()Anda akan mendapatkan kesalahan pernyataan (hanya dalam mode debug).

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
}

Maka Anda hanya perlu memanggil fungsi setFirstAppLaunch()di awal aplikasi Anda dan isFirstAppLaunch()kapan pun Anda ingin memeriksa apakah aplikasi Anda telah dipanggil.