Déterminer si l'application Android est utilisée pour la première fois

Je développe actuellement une application Android. J'ai besoin de faire quelque chose lorsque l'application est lancée pour la première fois, c'est-à-dire que le code ne s'exécute qu'au premier lancement du programme.

Une autre idée consiste à utiliser un paramètre dans les préférences partagées. Même idée générale que de rechercher un fichier vide, mais vous n'avez pas de fichier vide flottant, n'étant pas utilisé pour stocker quoi que ce soit

Vous pouvez utiliser les SharedPreferences pour identifier si c'est la «première fois» que l'application est lancée. Utilisez simplement une variable booléenne ("my_first_time") et changez sa valeur en false lorsque votre tâche pour la "première fois" est terminée.

Voici mon code pour attraper la première fois que vous ouvrez l'application:

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

Je suggère de stocker non seulement un drapeau booléen, mais le code de version complet. De cette façon, vous pouvez également demander au début s'il s'agit du premier démarrage d'une nouvelle version. Vous pouvez utiliser ces informations pour afficher une boîte de dialogue "Quoi de neuf", par exemple.

Le code suivant doit fonctionner à partir de n'importe quelle classe Android qui "est un contexte" (activités, services, ...). Si vous préférez l'avoir dans une classe distincte (POJO), vous pouvez envisager d'utiliser un "contexte statique", comme décrit ici par exemple.

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

Il pourrait être utilisé à partir d'une activité comme celle-ci:

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

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

La logique de base peut être vérifiée à l'aide de ce test 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));
}

Avec un peu plus d'effort, vous pourrez probablement tester également les éléments liés à Android (PackageManager et SharedPreferences). Quelqu'un intéressé à écrire le test? :)

Notez que le code ci-dessus ne fonctionnera correctement que si vous ne android:versionCodeplaisantez pas avec votre dans AndroidManifest.xml!

J'ai résolu de déterminer si l'application est votre première fois ou non, selon qu'il s'agit d'une mise à jour.

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

Calculer les résultats:

• 0: si c'est la première fois.
• 1: Cela n'a jamais commencé.
• 2: Il a démarré une fois, mais pas cette version, c'est à dire qu'il s'agit d'une mise à jour.

Vous pouvez utiliser Android SharedPreferences .

Android SharedPreferences nous permet de stocker des données d'application primitives privées sous la forme d'une paire clé-valeur.

CODE

Créer une classe personnalisée 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;
    }

}

Ouvrez maintenant votre activité et initialisez .

 private     SharedPreference                sharedPreferenceObj; // Declare Global

Appelez maintenant ceci dans la section OnCreate

 sharedPreferenceObj=new SharedPreference(YourActivity.this);

Vérification en cours

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
 }

Voici un code pour cela -

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

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

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

Vous pouvez simplement vérifier l'existence d'un fichier vide, s'il n'existe pas, puis exécuter votre code et créer le fichier.

par exemple

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

J'ai fait une classe simple pour vérifier si votre code s'exécute pour la première fois / n fois!

Exemple

Créez des préférences uniques

FirstTimePreference prefFirstTime = new FirstTimePreference(getApplicationContext());

Utilisez runTheFirstTime, choisissez une clé pour vérifier votre événement

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

Utilisez runTheFirstNTimes, choisissez une clé et combien de fois exécuter

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

• Utilisez getCountDown () pour mieux gérer votre code

FirstTimePreference.java

Il y a un support pour cela dans la révision 23.3.0 de la bibliothèque de support (dans la v4, ce qui signifie la compatibilité avec Android 1.6).

Dans votre activité Launcher, appelez d'abord:

AppLaunchChecker.onActivityCreate(activity);

Puis appelez:

AppLaunchChecker.hasStartedFromLauncher(activity);

Ce qui reviendra si c'était la première fois que l'application était lancée.

Si vous cherchez un moyen simple, le voici.

Créez une classe utilitaire comme celle-ci,

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

}

Dans votre activité principale, onCreate ()

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

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

}

Pourquoi ne pas utiliser l'Assistant de base de données? Cela aura un joli onCreate qui n'est appelé que la première fois que l'application est démarrée. Cela aidera les personnes qui souhaitent suivre cela après l'installation de l'application initiale sans suivi.

J'aime avoir un "nombre de mises à jour" dans mes préférences partagées. Si ce n'est pas là (ou valeur zéro par défaut), il s'agit de la "première utilisation" de mon application.

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

Alors maintenant, chaque fois qu'il y a une mise à jour de l'application que les utilisateurs devraient connaître, j'incrémente 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);

Salut les gars, je fais quelque chose comme ça. Et ça marche pour moi

créer un champ booléen dans la préférence partagée. La valeur par défaut est true {isFirstTime: true} après la première fois, définissez-la sur false. Rien ne peut être simple et fiable que cela dans le système Android.