IPhone पर पहली बार ऐप लॉन्च का पता कैसे लगाएं

163

मैं पहली बार लॉन्च होने का पता कैसे लगा सकता हूं 

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

तरीका?

ios  iphone  launch  launching-application 
— Shishir.bobby
स्रोत
मुझे लगता है कि stackoverflow.com/questions/5456134/iphone-launch-options आपकी मदद करेगा
— चरण

जवाबों:

386 
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    if (![[NSUserDefaults standardUserDefaults] boolForKey:@"HasLaunchedOnce"])
    {
        [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"HasLaunchedOnce"];
        [[NSUserDefaults standardUserDefaults] synchronize];
    }
    return YES;
}
— समीरा आर।
स्रोत
मुझे एक त्रुटि मिलती है क्योंकि विधि एक बूलियन मान नहीं दे रही है। अगर मैं रिटर्न 0 का उपयोग करता हूं; त्रुटि को मारने के लिए यह विफल रहता है।
— mrEmpty
@mrEmpty 1. ??? यह लौट आता है BOOL। 2. फिर त्रुटि आपके कोड में है ... यदि 0 वापस करना यह दुर्घटना बनाता है, तो कुछ बहुत गलत है - कहीं और।
@ H2CO3 - NSUserDefaultsएक आम जगह नहीं है? क्या होगा यदि कोई अन्य एप्लिकेशन उसी "कुंजी" का उपयोग करता है जिसका मैं उपयोग कर रहा हूं?
— ज़िव लेवी
6
@ZivLevy नहीं, उपयोगकर्ता डिफॉल्ट्स को प्रति-सैंडबॉक्स (= प्रति-एप्लिकेशन) आधार पर एक संपत्ति सूची में संग्रहीत किया जाता है।
2
यह केवल उन नए ऐप्स के लिए काम करेगा जो पहले कभी प्रस्तुत नहीं किए गए हैं।
— इलाद
36

में स्विफ्ट 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
        }
    }

में स्विफ्ट 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 सी मैं इस का उपयोग करें,

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

OBJ-C के लिए Ref: https://stackoverflow.com/a/9964400/3411787

— मोहम्मद जैद पठान
स्रोत
32

मैंने इसी उद्देश्य से एक छोटी सी लाइब्रेरी लिखी। यह मुझे बताता है कि क्या यह अब तक का पहला लॉन्च है, या केवल इस संस्करण के लिए, और उपयोगकर्ता द्वारा स्थापित किसी भी पिछले संस्करण में। यह अपाचे 2 लाइसेंस: GBVersionTracking के तहत एक कोकोकोप के रूप में जीथब पर उपलब्ध है

आप बस इसमें कॉल करें application:didFinishLaunching:withOptions:

[GBVersionTracking track];

और फिर यह जांचने के लिए कि क्या यह पहला लॉन्च है, बस इसे कहीं भी कॉल करें:

[GBVersionTracking isFirstLaunchEver];

और इसी तरह:

[GBVersionTracking isFirstLaunchForVersion];

[GBVersionTracking currentVersion];
[GBVersionTracking previousVersion];
[GBVersionTracking versionHistory];
— LMS
स्रोत
1
यह लगभग सही है! GBToolbox निर्भरता और एक पॉडसेप के बिना बहुत बढ़िया रहा होगा।
— स्टियन होइलैंड
4
@ StianHøiland GBToolbox निर्भरता दूर हो गई है, और पुस्तकालय एक पॉडसेप (कोकोपॉड स्पेक्स रेपो के लिए प्रकाशित) के साथ आता है।
— LMS
9

स्विफ्ट 3.0 के लिए - स्विफ्ट 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()
— KIO
स्रोत
8

एक्सकोड 7 और स्विफ्ट 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
}
— डेनिस-tra
स्रोत
8

आप इसे नीचे स्टैटिक विधि से लागू कर सकते हैं:

+ (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;
}
— माटी बॉट
स्रोत
ध्यान रखें कि यदि आप चाहते हैं कि यह थ्रेड सुरक्षित हो तो आपको इस विधि को लॉक करने की आवश्यकता है।
— मत्ती बॉट
9
मुझे पता है, लेकिन यह तरीका नहीं है। 2 थ्रेड्स पहुंच सकते हैं अगर (! झंडा) {जब झंडा नं। वे अगर ब्लॉक के अंदर मिल जाएगा। उनमें से एक आंतरिक रूप से मिलेगा और NSUserDefaults सेट करेगा और दूसरा "hasLaunchOnce" पास करेगा (क्योंकि पहले थ्रेड ने इसे घोषित किया था) और NO को परिणाम सेट किया था। इसका मतलब है कि आप गलत मूल्य प्राप्त कर सकते हैं।
— मति बॉट
5

जब आप लॉन्च करते हैं तो आपको कुछ बचत करने की आवश्यकता होती है और फिर यह देखने के लिए जांचें कि क्या यह मौजूद है। यदि नहीं, तो यह पहली बार है। "कुछ" एक फ़ाइल, एक डेटाबेस प्रविष्टि, उपयोगकर्ता चूक में एक सेटिंग हो सकती है ...।

— फिलिप मिल्स
स्रोत
4

यह ऐसा करने के लिए काफी सरल है और कोड की केवल छह पंक्तियों की आवश्यकता है।

इस एप्लिकेशन को आपकी एप्लिकेशन लॉन्च प्राथमिकताओं में शामिल करना उपयोगी होगा या कहीं और आपको यह परीक्षण करने की आवश्यकता हो सकती है कि आपका आवेदन पहली बार चला है या नहीं।

//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 वरीयताओं में बूल का उपयोग न करें बस पूर्णांक से चिपके रहें। अपरिभाषित होने पर वे शून्य पर डिफ़ॉल्ट हो जाते हैं।

इसके अलावा, [theDefaults synchronize];लाइन की आवश्यकता नहीं है, लेकिन मैंने पाया है कि जब एक ऐप को सैकड़ों उपकरणों पर सैकड़ों बार चलाया जाता है, तो परिणाम हमेशा विश्वसनीय नहीं होते हैं, इसके अलावा, यह बेहतर अभ्यास है।

— मिलो
स्रोत
आपका उदाहरण काम करता है, लेकिन सभी ओपी पूछते हैं कि यह पहली शुरुआत है या नहीं। एक बूल इसके लिए पूरी तरह से ठीक है। आपका कोड समझ में आता है अगर कोई यह जानना चाहता है कि उपयोगकर्ता ने कितनी बार ऐप खोला है।
— तिलो
3

NSUserDefaults में पहली बार एक बूल कुंजी संग्रहीत करें, यह नहीं होगा कि आप इसे हां में बदल देंगे और इसे इस तरह रखेंगे कि जब तक ऐप डिलीट या पुनर्स्थापना नहीं करेगा, तब तक यह पहली बार फिर से होगा।

— Malek_Jundi
स्रोत
3

त्वरित और आसान कार्य

- (BOOL) isFirstTimeOpening {
    NSUserDefaults *theDefaults = [NSUserDefaults standardUserDefaults];
    if([theDefaults integerForKey:@"hasRun"] == 0) {
        [theDefaults setInteger:1 forKey:@"hasRun"];
        [theDefaults synchronize];
        return true;
    }
    return false;
}
— क्रिस Fremgen
स्रोत
3

Xcode 7 में स्विफ्ट 2.0 के लिए। 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
    }
}

}
— MB_iOSDeveloper
स्रोत
2

तीव्र

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
— Prcela
स्रोत
2

स्विफ्ट में मैं एक वैश्विक स्थिरांक का उपयोग करने का सुझाव दूंगा जो कि किसी भी दायरे के बाहर बहुत आसानी से किया जा सकता है जैसे कि ऐप प्रतिनिधि के ऊपर। इस प्रकार यह तब तक के लिए सही मूल्य पर सेट हो जाएगा जब तक कि ऐप समाप्त नहीं हो जाता। यदि ऐप बैकग्राउंड में चला जाता है तो यह उसी मान को लौटाएगा। यदि ऐप पूरी तरह से फिर से लॉन्च किया जाता है तो मूल्य बदल जाएगा।

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

लेकिन ईमानदारी से इस तथ्य को ट्रैक करना बेहतर है कि ऐप को कम से कम एक बार पृष्ठभूमि पर भेजा गया है। ऐसे मामले में मैं UIApplication पर एक्सटेंशन का उपयोग करना पसंद करता हूं और एप्लिकेशन में फ्लैग सेट करता हूं

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()
    }
— निकोलस मंज़िनी
स्रोत
2

स्विफ्ट 5 आईओएस 13।

मुझे क्रिस फ्रेमगेन द्वारा त्वरित और आसान पसंद है । इसलिए मैंने इसे अपडेट किया।

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

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

}
— user3069232
स्रोत
2

XCode 11 , स्विफ्ट 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()
— sasquatch
स्रोत
0

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
}
— फर्नांडो ग्रीवांस
स्रोत
0

यहां स्विफ्ट 5.0 में काम करने का जवाब है। @Zaid पठान के जवाब की तुलना में सुधार यह है कि कोई छिपा हुआ अनुबंध नहीं है। यदि आप कॉल करने से पहले एक बार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()जब भी आप चेक करना चाहते हैं कि आपका ऐप कॉल किया गया है या नहीं।

— कल्प
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.