निर्धारित करें कि क्या एंड्रॉइड ऐप का उपयोग पहली बार किया जा रहा है

112

मैं वर्तमान में एक Android ऐप विकसित कर रहा हूं। जब ऐप पहली बार लॉन्च किया जाता है, तो मुझे कुछ करने की ज़रूरत होती है, यानी कोड केवल पहली बार प्रोग्राम लॉन्च होने पर चलता है।

android 
— Boardy
स्रोत
1
जब मैंने पहली बार ऐप बनाना शुरू किया, तो मैं केवल ऐप चलाने के बाद पहले रन के बारे में सोच रहा था। मुझे बाद में एहसास हुआ कि मुझे अपग्रेड के बाद पहले रन को संभालने और अलग करने की भी जरूरत है। @ नीचे schnatterer का उत्तर और यहाँ मेरा उत्तर यह दिखाता है कि यह कैसे करना है। उन उत्तरों से सावधान रहें जो अपग्रेड को ध्यान में नहीं रखते हैं।
— सूर्याग
@ आप जिस तरह से अभिनय कर रहे हैं, वह खराब है, इसलिए अपग्रेड को ध्यान में नहीं रखना बुरी बात है, लेकिन कुछ मामलों में जैसे कि एक ऐप इंट्रोडक्शन जो आप करना नहीं चाहते हैं :)
— रचनात्मक
@creativecreatorormaybenot, यह सच है। ऐसे समय होते हैं जब आप केवल शुरुआती इंस्टॉल और बाद में अपग्रेड के बारे में परवाह करते हैं। एक साधारण बूलियन उन स्थितियों के लिए पर्याप्त है। हालाँकि, क्या होगा अगर भविष्य में किसी समय आप वर्तमान उपयोगकर्ताओं के लिए एक अलग परिचय जोड़ना चाहते हैं, जो आपने पिछले अपडेट में जोड़े हैं? मेरी राय में यह बूलियन के बजाय संस्करण संख्या की जांच करने के लिए अधिक दूरदर्शी है। यह कम से कम आपको भविष्य में नए इंस्टाल के लिए एक तरीके और एक अपग्रेड के लिए दूसरे तरीके का जवाब देने का विकल्प देता है।
— सुरगाछ
1
तो आप बस इसे इस संस्करण के लिए जोड़ते हैं, लेकिन मैं yoz मिलता है
— रचनात्मक
— वैभव

जवाबों:

56

एक अन्य विचार साझा प्राथमिकता में एक सेटिंग का उपयोग करना है। एक खाली फ़ाइल की जाँच के रूप में समान सामान्य विचार, लेकिन तब आपके पास कोई भी खाली फ़ाइल नहीं होती है, जिसका उपयोग किसी भी चीज़ को संग्रहीत करने के लिए नहीं किया जाता है

— केविन डायोन
स्रोत
3
सावधान रहें कि एंड्रॉइड फ्राईओ के साथ सैमसंग गैलेक्सी एस पर इस तरह का दृष्टिकोण काम नहीं कर सकता है। ऐसा इसलिए है क्योंकि SharedPreferences बचत में एक बग। यहाँ उस पर SO प्रश्न का लिंक दिया गया है: stackoverflow.com/questions/7296163/… और यहाँ गूगल टिकट पर टिकट है: code.google.com/p/android/issues/detail?id=14359
— फ्रांसेस रिगोनी
4
Android 6.0 (एपीआई 23 - मार्शमैलो) या इसके बाद के संस्करण के लिए ऑटो बैकअप ( डेवलपर. android.com/guide/topics/data/autobackup.html)is डिफ़ॉल्ट रूप से सक्षम किया गया। अगर यूजर्स अनइंस्टॉल करते हैं और फिर एप को रीइंस्टॉल करते हैं तो साझा प्राथमिकताएं वापस मिल जाएंगी। यदि आप किसी भी चिंता का विषय है तो पुनर्स्थापना के बाद पहली बार चल रहा है, तो आप इसे बहाल नहीं कर सकते।
— एलन
1
@ यदि आप सही हैं, तो यह उत्तर Android मार्शमैलो से मान्य नहीं है।
— इयाने शरवाद्ज़े
1
@ क्या आप अंदाजा नहीं लगा सकते कि मैं कब तक आपके जैसे जवाब की तलाश में था। आपने मेरा दिन बना दिया। धन्यवाद!
— एंटोनियो
@Alan लेकिन ऑटो बैकअप अधिकांश अन्य डेटा भी बचाता है। इसलिए पुनः इंस्टॉल किया गया ऐप संभवतः गैर-प्रथम-संचालित स्थिति में होने की उम्मीद है। और उपयोगकर्ता पहले ही ऐप का उपयोग कर चुका है, इसलिए मार्गदर्शन की कोई आवश्यकता नहीं है। इसलिए मैं ज्यादातर मामलों के लिए बहस करूंगा यह एक अच्छी बात है।
— smdufb
112

आप यह पहचानने के लिए कि क्या यह ऐप पहली बार लॉन्च किया गया है, साझा करने के लिए आप SharedPreferences का उपयोग कर सकते हैं । बस एक का उपयोग बूलियन चर ( "my_first_time") और करने के लिए अपने मूल्य बदलने के झूठे जब "पहली बार" के लिए अपने कार्य को खत्म हो गया है।

यह पहली बार है जब आप ऐप खोलेंगे

final String PREFS_NAME = "MyPrefsFile";

SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);

if (settings.getBoolean("my_first_time", true)) {
    //the app is being launched for first time, do something        
    Log.d("Comments", "First time");

             // first time task

    // record the fact that the app has been started at least once
    settings.edit().putBoolean("my_first_time", false).commit(); 
}
— harrakiss
स्रोत
17
क्या यह तब संभालेगा जब ऐप को Google play store पर अगले संस्करण में अपडेट किया जाएगा?
— शाज़ील अफ़ज़ल
4
नवीनीकरण के दौरान साझा किए गए साझाकरण बनाए रखे जाते हैं। इसलिए, मुझे लगता है कि जब प्लेस्टोर से अपग्रेड किया जा रहा है, तो पुराना मूल्य उपलब्ध है। वास्तव में यह अन्य तरीकों के लिए लागू होता है यानी फ़ाइल के अस्तित्व की जाँच करना। तो, उस स्थिति में शॉर्टकट विधि विभिन्न वरीयता / फ़ाइल नाम या मूल्य का उपयोग करने के लिए है।
— तेजस्वी हेगड़े
@ShajeelAfzal कुछ इस तरह से आपको सार्वजनिक शून्य की जाँच करने में मदद कर सकती है CheckAndInitAppFirstTime () {अंतिम स्ट्रिंग PREFS_NAME = "TheAppVer"; अंतिम स्ट्रिंग CHECK_VERSION = "1"; // आवश्यक सत्यापन ... अंतिम स्ट्रिंग KEY_NAME = "चेकवर्जन"; SharedPreferences सेटिंग = getSaringPreferences (PREFS_NAME, 0); अगर ((settings.getString (KEY_NAME, "0")। बराबर (CHECK_VERSION)) {// पहली बार ऐप लॉन्च किया जा रहा है, तो कुछ करें या CHECK_VERSION अलग है // ... settings .it ()। putString () KEY_NAME, CHECK_VERSION) .commit (); }}
— तेजस्वी हेगड़े
@ ओमान वर्मा: डेवलपर .android.com/reference/android/content/ पर getBoolean विवरण के अनुसार, getBoolean का दूसरा पैरामीटर डिफ़ॉल्ट मान है यदि पहला पैरामीटर बाहर नहीं निकलता है, तो यदि "my_first_time" सेट नहीं किया गया है अभिव्यक्ति सत्य के लिए चूक जाती है।
— user2798692
62

मेरा सुझाव है कि न केवल एक बूलियन ध्वज को स्टोर करें, बल्कि पूर्ण संस्करण कोड। इस तरह आप शुरुआत में भी क्वेरी कर सकते हैं यदि यह एक नए संस्करण में पहली शुरुआत है। आप इस जानकारी का उपयोग उदाहरण के लिए "व्हाट्सएप नया" संवाद प्रदर्शित करने के लिए कर सकते हैं।

निम्नलिखित कोड को किसी भी एंड्रॉइड क्लास से काम करना चाहिए जो "एक संदर्भ है" (गतिविधियां, सेवाएं, ...)। यदि आप इसे एक अलग (पीओजेओ) वर्ग में रखना पसंद करते हैं, तो आप "स्थिर संदर्भ" का उपयोग करने पर विचार कर सकते हैं , उदाहरण के लिए यहां वर्णित है ।

/**
 * Distinguishes different kinds of app starts: <li>
 * <ul>
 * First start ever ({@link #FIRST_TIME})
 * </ul>
 * <ul>
 * First start in this version ({@link #FIRST_TIME_VERSION})
 * </ul>
 * <ul>
 * Normal app start ({@link #NORMAL})
 * </ul>
 * 
 * @author schnatterer
 * 
 */
public enum AppStart {
    FIRST_TIME, FIRST_TIME_VERSION, NORMAL;
}

/**
 * The app version code (not the version name!) that was used on the last
 * start of the app.
 */
private static final String LAST_APP_VERSION = "last_app_version";

/**
 * Finds out started for the first time (ever or in the current version).<br/>
 * <br/>
 * Note: This method is <b>not idempotent</b> only the first call will
 * determine the proper result. Any subsequent calls will only return
 * {@link AppStart#NORMAL} until the app is started again. So you might want
 * to consider caching the result!
 * 
 * @return the type of app start
 */
public AppStart checkAppStart() {
    PackageInfo pInfo;
    SharedPreferences sharedPreferences = PreferenceManager
            .getDefaultSharedPreferences(this);
    AppStart appStart = AppStart.NORMAL;
    try {
        pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
        int lastVersionCode = sharedPreferences
                .getInt(LAST_APP_VERSION, -1);
        int currentVersionCode = pInfo.versionCode;
        appStart = checkAppStart(currentVersionCode, lastVersionCode);
        // Update version in preferences
        sharedPreferences.edit()
                .putInt(LAST_APP_VERSION, currentVersionCode).commit();
    } catch (NameNotFoundException e) {
        Log.w(Constants.LOG,
                "Unable to determine current app version from pacakge manager. Defenisvely assuming normal app start.");
    }
    return appStart;
}

public AppStart checkAppStart(int currentVersionCode, int lastVersionCode) {
    if (lastVersionCode == -1) {
        return AppStart.FIRST_TIME;
    } else if (lastVersionCode < currentVersionCode) {
        return AppStart.FIRST_TIME_VERSION;
    } else if (lastVersionCode > currentVersionCode) {
        Log.w(Constants.LOG, "Current version code (" + currentVersionCode
                + ") is less then the one recognized on last startup ("
                + lastVersionCode
                + "). Defenisvely assuming normal app start.");
        return AppStart.NORMAL;
    } else {
        return AppStart.NORMAL;
    }
}

इसका उपयोग इस तरह की गतिविधि से किया जा सकता है:

public class MainActivity extends Activity {        
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        switch (checkAppStart()) {
        case NORMAL:
            // We don't want to get on the user's nerves
            break;
        case FIRST_TIME_VERSION:
            // TODO show what's new
            break;
        case FIRST_TIME:
            // TODO show a tutorial
            break;
        default:
            break;
        }

        // ...
    }
    // ...
}

इस JUnit परीक्षण का उपयोग करके मूल तर्क को सत्यापित किया जा सकता है:

public void testCheckAppStart() {
    // First start
    int oldVersion = -1;
    int newVersion = 1;
    assertEquals("Unexpected result", AppStart.FIRST_TIME,
            service.checkAppStart(newVersion, oldVersion));

    // First start this version
    oldVersion = 1;
    newVersion = 2;
    assertEquals("Unexpected result", AppStart.FIRST_TIME_VERSION,
            service.checkAppStart(newVersion, oldVersion));

    // Normal start
    oldVersion = 2;
    newVersion = 2;
    assertEquals("Unexpected result", AppStart.NORMAL,
            service.checkAppStart(newVersion, oldVersion));
}

थोड़े अधिक प्रयास के साथ आप शायद Android से संबंधित सामान (PackageManager और SharedPreferences) का परीक्षण कर सकते हैं। परीक्षण लिखने में कोई दिलचस्पी है? :)

ध्यान दें कि यदि आप android:versionCodeAndroidManifest.xml में अपने साथ गड़बड़ नहीं करते हैं तो उपरोक्त कोड ठीक से काम करेगा !

— schnatterer
स्रोत
2
कृपया इस विधि का उपयोग करने का तरीका बताएं। जहाँ आप SharedPreferences ऑब्जेक्ट को प्रारंभ कर रहे हैं?
— शाजिल अफजल
1
मेरे लिए काम नहीं करता है - यह हमेशा मेरा पहला ट्यूटोरियल शुरू करता है
— pzo
1
इस कोड को बहुत अधिक सीधे संदर्भ और कहीं और वरीयताओं को घोषित करने के साइड इफेक्ट के बिना आगे है public AppStart checkAppStart(Context context, SharedPreferences sharedPreferences)एक बेहतर विधि हस्ताक्षर है
— विल
2
इस उत्तर का अद्यतन यहाँ उपलब्ध कराएँ । gist.github.com/williscool/2a57bcd47a206e980eee मेरे पास मूल कोड के साथ एक समस्या थी जहाँ यह हमेशा के लिए मेरे पूर्वाभ्यास पाश में फंस जाता था क्योंकि संस्करण संख्या पहले checkAppStartब्लॉक में कभी पुनर्गणित नहीं हो रही थी । इसलिए मैं अपने अपडेट किए गए कोड को साझा करें और देखें कि किसी को भी इसके बारे में सुझाव है का फैसला किया
— विल
1
@ आपके इनपुट के लिए धन्यवाद। आप सही हैं, कोड को सरल बनाया जा सकता है और अधिक मजबूत बनाया जा सकता है। जब मैंने पहली बार उत्तर पोस्ट किया, तो मैंने एक अधिक जटिल परिदृश्य से कोड निकाला , जहां मैं AppStartविभिन्न गतिविधियों से पहुंचना चाहता था । इसलिए मैंने तर्क को एक अलग सेवा पद्धति में रखा। यही कारण है कि एक contextवैरिएबल AppStartथा और एक स्थिर वैरिएबल के भीतर संग्रहीत किया गया था ताकि बेरोजगार विधि कॉल की सुविधा मिल सके।
— श्नाटर
4

मैंने यह निर्धारित करने के लिए हल किया कि क्या यह आपका आवेदन पहली बार है या नहीं, यह इस बात पर निर्भर करता है कि यह अपडेट है या नहीं।

private int appGetFirstTimeRun() {
    //Check if App Start First Time
    SharedPreferences appPreferences = getSharedPreferences("MyAPP", 0);
    int appCurrentBuildVersion = BuildConfig.VERSION_CODE;
    int appLastBuildVersion = appPreferences.getInt("app_first_time", 0);

    //Log.d("appPreferences", "app_first_time = " + appLastBuildVersion);

    if (appLastBuildVersion == appCurrentBuildVersion ) {
        return 1; //ya has iniciado la appp alguna vez

    } else {
        appPreferences.edit().putInt("app_first_time",
                appCurrentBuildVersion).apply();
        if (appLastBuildVersion == 0) {
            return 0; //es la primera vez
        } else {
            return 2; //es una versión nueva
        }
    }
}

गणना परिणाम:

  • 0: यदि यह पहली बार है।
  • 1: इसकी शुरुआत कभी हुई है।
  • 2: यह एक बार शुरू हुआ है, लेकिन यह संस्करण नहीं है, अर्थात यह एक अद्यतन है।
— Webserveis
स्रोत
3

आप Android SharedPreferences का उपयोग कर सकते हैं ।

Android SharedPreferences हमें कुंजी-मूल्य जोड़ी के रूप में निजी आदिम अनुप्रयोग डेटा संग्रहीत करने की अनुमति देता है।

कोड

एक कस्टम वर्ग साझाकरण बनाएँ

 public class SharedPreference {

    android.content.SharedPreferences pref;
    android.content.SharedPreferences.Editor editor;
    Context _context;
    private static final String PREF_NAME = "testing";

    // All Shared Preferences Keys Declare as #public
    public static final String KEY_SET_APP_RUN_FIRST_TIME       =        "KEY_SET_APP_RUN_FIRST_TIME";


    public SharedPreference(Context context) // Constructor
    {
        this._context = context;
        pref = _context.getSharedPreferences(PREF_NAME, 0);
        editor = pref.edit();

    }

    /*
    *  Set Method Generally Store Data;
    *  Get Method Generally Retrieve Data ;
    * */


    public void setApp_runFirst(String App_runFirst)
    {
        editor.remove(KEY_SET_APP_RUN_FIRST_TIME);
        editor.putString(KEY_SET_APP_RUN_FIRST_TIME, App_runFirst);
        editor.apply();
    }

    public String getApp_runFirst()
    {
        String  App_runFirst= pref.getString(KEY_SET_APP_RUN_FIRST_TIME, "FIRST");
        return  App_runFirst;
    }

}

अब अपनी गतिविधि खोलें और आरंभ करें ।

 private     SharedPreference                sharedPreferenceObj; // Declare Global

अब इसे OnCreate सेक्शन में कॉल करें

 sharedPreferenceObj=new SharedPreference(YourActivity.this);

अब जाँच हो रही है

if(sharedPreferenceObj.getApp_runFirst().equals("FIRST"))
 {
   // That's mean First Time Launch
   // After your Work , SET Status NO
   sharedPreferenceObj.setApp_runFirst("NO");
 }
else
 { 
   // App is not First Time Launch
 }
— इंटेलीज अमिया
स्रोत
2

इसके लिए यहां कुछ कोड दिया गया है - 

String path = Environment.getExternalStorageDirectory().getAbsolutePath() +
                    "/Android/data/myapp/files/myfile.txt";

boolean exists = (new File(path)).exists(); 

if (!exists) {
    doSomething();                                      
}
else {
    doSomethingElse();
}
— अरुणाभ दास
स्रोत
1

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

जैसे

if(File.Exists("emptyfile"){
    //Your code here
    File.Create("emptyfile");
}
— MechMK1
स्रोत
मैं ऐसा करने के बारे में सोच रहा था, लेकिन सोचा कि एक बेहतर तरीका होना चाहिए
— बोर्डी
मुझे कोई जानकारी नहीं है, लेकिन आपके द्वारा पुन: प्राप्त किए गए स्रोतों की कमी क्या है? फ़ाइल के लिए 4 बाइट्स और शुरुआत में एक "अगर"। सिस्टम-रूटीन वही करेंगे, वे बिल्कुल वैसा ही करेंगे या उन अनुप्रयोगों के साथ एक टेबल बना
— देंगे
इसी तरह के फैशन में आप साझाकरण का उपयोग कर सकते हैं, जो यदि मौजूद नहीं है, तो आप एक स्प्लैश स्क्रीन आदि दिखाते हैं ... और बस इसे तब बनाएं जब प्रोग्राम पहले चलाया जाता है (इसके लिए जाँच करने के बाद obv)। ऊपर केविन का उत्तर देखें
— स्टील्कॉप्टर
1

मैंने यह जांचने के लिए एक साधारण वर्ग बनाया कि आपका कोड पहली बार चल रहा है / n-times!

उदाहरण

एक अद्वितीय प्राथमिकताएँ बनाएँ

FirstTimePreference prefFirstTime = new FirstTimePreference(getApplicationContext());

RunTheFirstTime का उपयोग करें, अपनी घटना की जाँच करने के लिए एक कुंजी चुनें

if (prefFirstTime.runTheFirstTime("myKey")) {
    Toast.makeText(this, "Test myKey & coutdown: " + prefFirstTime.getCountDown("myKey"),
                   Toast.LENGTH_LONG).show();
}

RunTheFirstNTimes का उपयोग करें, एक कुंजी चुनें और कितनी बार निष्पादित करें

if(prefFirstTime.runTheFirstNTimes("anotherKey" , 5)) {
    Toast.makeText(this, "ciccia Test coutdown: "+ prefFirstTime.getCountDown("anotherKey"),
                   Toast.LENGTH_LONG).show();
}
  • अपने कोड को बेहतर तरीके से संभालने के लिए getCountDown () का उपयोग करें

FirstTimePreference.java

— Alu84
स्रोत
1

सपोर्ट लाइब्रेरी रिविजन 23.3.0 (v4 में जिसका अर्थ है एंड्रॉइड 1.6 पर वापस कम्पैटिबिलिटी वापस) के लिए बस इसके लिए सपोर्ट मौजूद है।

अपनी लॉन्चर गतिविधि में, पहले कॉल करें:

AppLaunchChecker.onActivityCreate(activity);

फिर कॉल करो:

AppLaunchChecker.hasStartedFromLauncher(activity);

अगर यह पहली बार था जब ऐप लॉन्च किया गया था।

— लुकास Arrefelt
स्रोत
एक बार AppLaunchChecker.onActivityCreate () कहा जाता है, तो इन कॉलों के क्रम को उलट देना होगा।
— गैरी किपनीस
यह काफी भ्रामक है। यह नहीं कहता कि क्या ऐप "कभी लॉन्च किया गया" है; बल्कि, यह कहता है कि क्या ऐप "लॉन्चर से किसी उपयोगकर्ता द्वारा लॉन्च किया गया है"। इसलिए, ऐसी संभावना है कि अन्य ऐप या डीप-लिंक ने ऐप को पहले ही लॉन्च कर दिया होगा।
— फरीद
1

यदि आप एक सरल तरीके की तलाश कर रहे हैं, तो यहां यह है।

इस तरह एक उपयोगिता वर्ग बनाएँ,

public class ApplicationUtils {

  /**
  * Sets the boolean preference value
  *
  * @param context the current context
  * @param key     the preference key
  * @param value   the value to be set
  */
 public static void setBooleanPreferenceValue(Context context, String key, boolean value) {
     SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
     sp.edit().putBoolean(key, value).apply();
 }

 /**
  * Get the boolean preference value from the SharedPreference
  *
  * @param context the current context
  * @param key     the preference key
  * @return the the preference value
  */
 public static boolean getBooleanPreferenceValue(Context context, String key) {
     SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
     return sp.getBoolean(key, false);
 }

}

आपकी मुख्य गतिविधि पर, ऑनक्रीट ()

if(!ApplicationUtils.getBooleanPreferenceValue(this,"isFirstTimeExecution")){
Log.d(TAG, "First time Execution");
ApplicationUtils.setBooleanPreferenceValue(this,"isFirstTimeExecution",true);
// do your first time execution stuff here,
}
— Hardian
स्रोत
1

कोटलिन के लिए

    fun checkFirstRun() {

    var prefs_name = "MyPrefsFile"
    var pref_version_code_key = "version_code"
    var doesnt_exist: Int = -1;

    // Get current version code
    var currentVersionCode = BuildConfig.VERSION_CODE

    // Get saved version code
    var prefs: SharedPreferences = getSharedPreferences(prefs_name, MODE_PRIVATE)
    var savedVersionCode: Int = prefs.getInt(pref_version_code_key, doesnt_exist)

    // Check for first run or upgrade
    if (currentVersionCode == savedVersionCode) {

        // This is just a normal run
        return;

    } else if (savedVersionCode == doesnt_exist) {

        // TODO This is a new install (or the user cleared the shared preferences)


    } else if (currentVersionCode > savedVersionCode) {

        // TODO This is an upgrade
    }

    // Update the shared preferences with the current version code
    prefs.edit().putInt(pref_version_code_key, currentVersionCode).apply();

}
— K.Hayoev
स्रोत
कोटलिन
— एमएमजी
0

डेटाबेस हेल्पर का उपयोग क्यों नहीं करते? यह एक अच्छा ऑनक्रिट होगा जिसे केवल पहली बार ऐप शुरू करने के लिए कहा जाता है। यह उन लोगों की मदद करेगा जो ट्रैकिंग के बिना शुरुआती ऐप इंस्टॉल किए जाने के बाद इसे ट्रैक करना चाहते हैं।

— slott
स्रोत
क्या वह डेटाबेस बनाता है? एक वास्तविक डेटाबेस बनाने के बिना DatabaseHelper का उपयोग कैसे करें? और मुझे लगता है, onCreate()हर नए संस्करण के लिए कहा जाता है। इसके अलावा, क्या इसे एक उद्देश्यपूर्ण उद्देश्य के लिए अतिशयोक्ति या कुछ का उपयोग नहीं माना जाएगा?
— ADTC
onCreate केवल तभी चालू होता है जब ऐप पहली बार इंस्टॉल किया जाता है। जब db संस्करण को बढ़ाया जाता है तो onUpdated को ट्रिगर किया जाता है।
— slott
अच्छी तरह से सतही एक ऐसा कठोर शब्द है :) - यदि आपके पास विकल्प है। आपका ऐप अभी तक लाइव नहीं है, फिर एक SharedPrefs ध्वज सेट करें और यह निर्धारित करने के लिए उपयोग करें कि यह पहली बार बूट है या नहीं। मेरे पास एक मामला था जहां ऐप कुछ समय के लिए जंगल में था और हम एक DB का उपयोग कर रहे थे इसलिए onCreate मेरे लिए एक आदर्श मैच था।
— slott
0

मुझे अपनी साझा प्राथमिकताओं में "अपडेट काउंट" रखना पसंद है। अगर यह नहीं है (या डिफ़ॉल्ट शून्य मान) तो यह मेरे ऐप का "पहला उपयोग" है।

private static final int UPDATE_COUNT = 1;    // Increment this on major change
...
if (sp.getInt("updateCount", 0) == 0) {
    // first use
} else if (sp.getInt("updateCount", 0) < UPDATE_COUNT) {
    // Pop up dialog telling user about new features
}
...
sp.edit().putInt("updateCount", UPDATE_COUNT);

इसलिए अब, जब भी उस ऐप के लिए कोई अपडेट होता है, जिसके बारे में उपयोगकर्ताओं को पता होना चाहिए, तो मैं UPDATE_COUNT बढ़ाता हूं

— एडवर्ड फॉक
स्रोत
-1 
    /**
     * @author ALGO
     */
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.util.UUID;

    import android.content.Context;

    public class Util {
        // ===========================================================
        //
        // ===========================================================

        private static final String INSTALLATION = "INSTALLATION";

        public synchronized static boolean isFirstLaunch(Context context) {
            String sID = null;
            boolean launchFlag = false;
            if (sID == null) {
                File installation = new File(context.getFilesDir(), INSTALLATION);
                try {
                    if (!installation.exists()) {

                        writeInstallationFile(installation);
                    }
                    sID = readInstallationFile(installation);
launchFlag = true;
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
            return launchFlag;
        }

        private static String readInstallationFile(File installation) throws IOException {
            RandomAccessFile f = new RandomAccessFile(installation, "r");// read only mode
            byte[] bytes = new byte[(int) f.length()];
            f.readFully(bytes);
            f.close();

            return new String(bytes);
        }

        private static void writeInstallationFile(File installation) throws IOException {
            FileOutputStream out = new FileOutputStream(installation);
            String id = UUID.randomUUID().toString();
            out.write(id.getBytes());
            out.close();
        }
    }

> Usage (in class extending android.app.Activity)

Util.isFirstLaunch(this);
— AZ_
स्रोत
-2

हाय दोस्तों मैं कुछ ऐसा कर रहा हूँ। और मेरे लिए इसका काम करता है

साझा प्राथमिकता में बूलियन फ़ील्ड बनाएं। डीफ़ॉल्ट मान सही है {isFirstTime: true} पहली बार इसे गलत पर सेट करने के बाद। एंड्रॉइड सिस्टम में इससे सरल और भरोसेमंद कुछ भी नहीं हो सकता है।

— DropAndTrap
स्रोत
उह, उस तरह से हार्डकोड मत करो! यदि आप बस करते हैं तो Context.getSharedPreferences()यह एक ही स्थान पर समाप्त हो जाएगा, सिवाय इसके कि यह हर जगह काम करेगा
— तख्तियन
आपसे सहमत हूं :)
— DropAndTrap
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.