Sprawdź, czy aplikacja na Androida jest używana po raz pierwszy

Obecnie pracuję nad aplikacją na Androida. Muszę coś zrobić, gdy aplikacja jest uruchamiana po raz pierwszy, tj. Kod działa tylko przy pierwszym uruchomieniu programu.

Innym pomysłem jest użycie ustawienia w Preferencjach wspólnych. Taka sama ogólna idea, jak sprawdzanie pustego pliku, ale wtedy nie masz pustego pliku, który nie jest używany do przechowywania niczego

Możesz użyć SharedPreferences, aby określić, czy jest to „pierwsze uruchomienie” aplikacji. Po prostu użyj zmiennej Boolean („my_first_time”) i zmień jej wartość na false, gdy Twoje zadanie „pierwszy raz” się zakończy.

Oto mój kod do złapania przy pierwszym uruchomieniu aplikacji:

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

Proponuję nie tylko przechowywać flagę logiczną, ale także cały kod wersji. W ten sposób możesz również zapytać na początku, czy jest to pierwszy start w nowej wersji. Możesz użyć tych informacji, aby na przykład wyświetlić okno dialogowe „Co nowego”.

Poniższy kod powinien działać z każdą klasą systemu Android, która „jest kontekstem” (działania, usługi, ...). Jeśli wolisz mieć go w oddzielnej klasie (POJO), możesz rozważyć użycie „kontekstu statycznego”, jak opisano na przykład tutaj .

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

Można go użyć z takiej czynnoś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;
        }

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

Podstawową logikę można zweryfikować za pomocą tego testu 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));
}

Przy odrobinie wysiłku możesz prawdopodobnie przetestować również rzeczy związane z Androidem (PackageManager i SharedPreferences). Czy ktoś jest zainteresowany napisaniem testu? :)

Zwróć uwagę, że powyższy kod będzie działał poprawnie tylko wtedy, gdy nie będziesz bałaganić android:versionCodew pliku AndroidManifest.xml!

Rozwiązałem, aby ustalić, czy aplikacja jest Twoja pierwsza, czy nie, w zależności od tego, czy jest to aktualizacja.

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

Oblicz wyniki:

• 0: Jeśli to pierwszy raz.
• 1: Zaczęło się kiedykolwiek.
• 2: Uruchomiono raz, ale nie tę wersję, tj. Jest to aktualizacja.

Możesz użyć wspólnych preferencji Androida .

Android SharedPreferences umożliwia nam przechowywanie prywatnych danych pierwotnych aplikacji w postaci pary klucz-wartość.

KOD

Utwórz niestandardową klasę 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;
    }

}

Teraz otwórz swoją aktywność i zainicjuj .

 private     SharedPreference                sharedPreferenceObj; // Declare Global

Teraz nazwij to w sekcji OnCreate

 sharedPreferenceObj=new SharedPreference(YourActivity.this);

Teraz sprawdzam

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
 }

Oto kod do tego -

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

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

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

Możesz po prostu sprawdzić, czy istnieje pusty plik, jeśli nie istnieje, a następnie wykonać kod i utworzyć plik.

na przykład

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

Zrobiłem prostą klasę, aby sprawdzić, czy Twój kod działa po raz pierwszy / n-razy!

Przykład

Stwórz unikalne preferencje

FirstTimePreference prefFirstTime = new FirstTimePreference(getApplicationContext());

Użyj runTheFirstTime, wybierz klucz, aby sprawdzić wydarzenie

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

Użyj runTheFirstNTimes, wybierz klucz i ile razy wykonaj

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

• Użyj metody getCountDown (), aby lepiej obsługiwać swój kod

FirstTimePreference.java

Jest to obsługiwane w wersji 23.3.0 biblioteki obsługi (w wersji 4, co oznacza kompatybilność z powrotem do Androida 1.6).

Podczas działania programu uruchamiającego pierwsze połączenie:

AppLaunchChecker.onActivityCreate(activity);

Wtedy zadzwoń:

AppLaunchChecker.hasStartedFromLauncher(activity);

Który powróci, jeśli będzie to pierwsze uruchomienie aplikacji.

Jeśli szukasz prostego sposobu, oto on.

Utwórz taką klasę użytkową,

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

}

W Twojej głównej aktywności onCreate ()

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

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

}

Dlaczego nie skorzystać z pomocnika bazy danych? Będzie to przyjemne narzędzie onCreate, które jest wywoływane tylko przy pierwszym uruchomieniu aplikacji. Pomoże to tym osobom, które chcą to śledzić po zainstalowaniu pierwszej aplikacji bez śledzenia.

Lubię mieć „liczbę aktualizacji” w moich wspólnych preferencjach. Jeśli go tam nie ma (lub domyślna wartość zerowa), oznacza to „pierwsze użycie” mojej aplikacji.

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

Dlatego teraz, gdy pojawia się aktualizacja aplikacji, o której użytkownicy powinni wiedzieć, zwiększam 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);

Cześć, robię coś takiego. I to działa na mnie

utwórz pole Boolean we wspólnych preferencjach. Wartość domyślna to true {isFirstTime: true} po pierwszym razem ustaw ją na false. Nic nie może być proste i niezawodne niż to w systemie Android.