Stellen Sie fest, ob die Android-App zum ersten Mal verwendet wird

Ich entwickle gerade eine Android App. Ich muss etwas tun, wenn die App zum ersten Mal gestartet wird, dh der Code wird nur beim ersten Start des Programms ausgeführt.

Eine andere Idee ist, eine Einstellung in den freigegebenen Einstellungen zu verwenden. Dieselbe allgemeine Idee wie das Suchen nach einer leeren Datei, aber dann schwebt keine leere Datei herum und wird nicht zum Speichern verwendet

Mithilfe der SharedPreferences können Sie feststellen , ob die App zum ersten Mal gestartet wird. Verwenden Sie einfach eine boolesche Variable ("my_first_time") und ändern Sie ihren Wert in false wenn Ihre Aufgabe zum "ersten Mal" beendet ist.

Dies ist mein Code, um beim ersten Öffnen der App abzufangen:

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

Ich schlage vor, nicht nur ein boolesches Flag, sondern den vollständigen Versionscode zu speichern. Auf diese Weise können Sie auch zu Beginn abfragen, ob dies der erste Start in einer neuen Version ist. Mit diesen Informationen können Sie beispielsweise ein Dialogfeld "Was ist neu" anzeigen.

Der folgende Code sollte von jeder Android-Klasse funktionieren, die "ein Kontext" ist (Aktivitäten, Dienste, ...). Wenn Sie es lieber in einer separaten Klasse (POJO) haben möchten, können Sie einen "statischen Kontext" verwenden, wie hier beispielsweise beschrieben.

/**
 * 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;
    }
}

Es könnte aus einer Aktivität wie dieser verwendet werden:

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

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

Die grundlegende Logik kann mit diesem JUnit-Test überprüft werden:

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

Mit etwas mehr Aufwand könnten Sie wahrscheinlich auch die Android-bezogenen Inhalte (PackageManager und SharedPreferences) testen. Hat jemand Interesse daran, den Test zu schreiben? :) :)

Beachten Sie, dass der obige Code nur dann ordnungsgemäß funktioniert, wenn Sie nicht mit Ihrem android:versionCodein AndroidManifest.xml herumspielen!

Ich habe festgestellt, ob die Anwendung Ihr erstes Mal ist oder nicht, je nachdem, ob es sich um ein Update handelt.

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

Ergebnisse berechnen:

• 0: Wenn dies das erste Mal ist.
• 1: Es hat jemals begonnen.
• 2: Es wurde einmal gestartet, aber nicht diese Version, dh es ist ein Update.

Sie können Android SharedPreferences verwenden .

Mit Android SharedPreferences können wir private primitive Anwendungsdaten in Form eines Schlüssel-Wert-Paares speichern.

CODE

Erstellen Sie eine benutzerdefinierte Klasse SharedPreference

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

}

Öffnen Sie jetzt Ihre Aktivität und initialisieren Sie sie .

 private     SharedPreference                sharedPreferenceObj; // Declare Global

Rufen Sie dies jetzt im Abschnitt OnCreate auf

 sharedPreferenceObj=new SharedPreference(YourActivity.this);

Jetzt prüfen

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
 }

Hier ist ein Code dafür -

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

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

if (!exists) {
    doSomething();                                      
}
else {
    doSomethingElse();
}

Sie können einfach prüfen, ob eine leere Datei vorhanden ist. Wenn diese nicht vorhanden ist, führen Sie Ihren Code aus und erstellen Sie die Datei.

z.B

if(File.Exists("emptyfile"){
    //Your code here
    File.Create("emptyfile");
}

Ich habe eine einfache Klasse erstellt, um zu überprüfen, ob Ihr Code zum ersten Mal / n-mal ausgeführt wird!

Beispiel

Erstellen Sie eindeutige Einstellungen

FirstTimePreference prefFirstTime = new FirstTimePreference(getApplicationContext());

Verwenden Sie runTheFirstTime und wählen Sie einen Schlüssel aus, um Ihr Ereignis zu überprüfen

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

Verwenden Sie runTheFirstNTimes, wählen Sie einen Schlüssel und wie oft ausgeführt

if(prefFirstTime.runTheFirstNTimes("anotherKey" , 5)) {
    Toast.makeText(this, "ciccia Test coutdown: "+ prefFirstTime.getCountDown("anotherKey"),
                   Toast.LENGTH_LONG).show();
}

• Verwenden Sie getCountDown (), um Ihren Code besser zu handhaben

FirstTimePreference.java

Genau dies wird in der Support-Bibliotheksversion 23.3.0 unterstützt (in Version 4 bedeutet dies Kompatibilität zurück zu Android 1.6).

Rufen Sie in Ihrer Launcher-Aktivität zuerst Folgendes auf:

AppLaunchChecker.onActivityCreate(activity);

Dann ruf an:

AppLaunchChecker.hasStartedFromLauncher(activity);

Welches wird zurückkehren, wenn dies das erste Mal war, dass die App gestartet wurde.

Wenn Sie nach einem einfachen Weg suchen, hier ist er.

Erstellen Sie eine Dienstprogrammklasse wie folgt:

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

}

Bei Ihrer Hauptaktivität ist onCreate ()

if(!ApplicationUtils.getBooleanPreferenceValue(this,"isFirstTimeExecution")){
Log.d(TAG, "First time Execution");
ApplicationUtils.setBooleanPreferenceValue(this,"isFirstTimeExecution",true);
// do your first time execution stuff here,
}

für Kotlin

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

}

Warum nicht den Database Helper verwenden? Dies hat eine schöne onCreate, die nur beim ersten Start der App aufgerufen wird. Dies hilft denjenigen Personen, die dies nachverfolgen möchten, nachdem die erste App ohne Nachverfolgung installiert wurde.

Ich möchte eine "Anzahl der Updates" in meinen gemeinsamen Einstellungen haben. Wenn es nicht vorhanden ist (oder der Standardwert Null ist), ist dies die "erste Verwendung" meiner App.

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);

Immer wenn es ein Update für die App gibt, über das Benutzer Bescheid wissen sollten, erhöhe ich UPDATE_COUNT

    /**
     * @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);

Hallo Leute, ich mache so etwas. Und es funktioniert für mich

Erstellen Sie ein boolesches Feld in der gemeinsamen Voreinstellung. Der Standardwert ist true {isFirstTime: true}, nachdem Sie es zum ersten Mal auf false gesetzt haben. Nichts kann einfacher und zuverlässiger sein als dies im Android-System.