Home » Android » Determine if android app is the first time used

Determine if android app is the first time used

Posted by: admin March 11, 2020 Leave a comment


I am currently developing an android app. I need to do something when the app is launched for the first time, i.e. the code only runs on the first time the program is launched.

How to&Answers:

Another idea is to use a setting in the Shared Preferences. Same general idea as checking for an empty file, but then you don’t have an empty file floating around, not being used to store anything


You can use the SharedPreferences to identify if it is the “First time” the app is launched.
Just use a Boolean variable (“my_first_time”) and change its value to false when your task for “first time” is over.

This is my code to catch the first time you open the app:

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


I suggest to not only store a boolean flag, but the complete version code.
This way you can also query at the beginning if it is the first start in a new version. You can use this information to display a “Whats new” dialog, for example.

The following code should work from any android class that “is a context” (activities, services, …). If you prefer to have it in a separate (POJO) class, you could consider using a “static context”, as described here for example.

 * 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 {

 * 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
    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
                .putInt(LAST_APP_VERSION, currentVersionCode).commit();
    } catch (NameNotFoundException e) {
                "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;

It could be used from an activity like this:

public class MainActivity extends Activity {        
    protected void onCreate(Bundle savedInstanceState) {

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

        // ...
    // ...

The basic logic can be verified using this JUnit test:

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

With a bit more effort you could probably test the android related stuff (PackageManager and SharedPreferences) as well.
Anyone interested in writing the test? 🙂

Note that the above code will only work properly if you don’t mess around with your android:versionCode in AndroidManifest.xml!


I solved to determine whether the application is your first time or not , depending on whether it is an update.

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 {
        if (appLastBuildVersion == 0) {
            return 0; //es la primera vez
        } else {
            return 2; //es una versión nueva

Compute results:

  • 0: If this is the first time.
  • 1: It has started ever.
  • 2: It has started once, but not that version , ie it is an update.


You can use Android SharedPreferences .

Android SharedPreferences allows us to store private primitive
application data in the form of key-value pair .


Create a custom class 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.putString(KEY_SET_APP_RUN_FIRST_TIME, App_runFirst);

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


Now Open Your Activity & Initialize .

 private     SharedPreference                sharedPreferenceObj; // Declare Global

Now Call this in OnCreate section

 sharedPreferenceObj=new SharedPreference(YourActivity.this);

Now Checking

   // That's mean First Time Launch
   // After your Work , SET Status NO
   // App is not First Time Launch


Here’s some code for this –

String path = Environment.getExternalStorageDirectory().getAbsolutePath() +

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

if (!exists) {
else {


You could simply check for the existence of an empty file, if it doesn’t exist, then execute your code and create the file.


    //Your code here


I made a simple class to check if your code is running for the first time/ n-times!


Create a unique preferences

FirstTimePreference prefFirstTime = new FirstTimePreference(getApplicationContext());

Use runTheFirstTime, choose a key to check your event

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

Use runTheFirstNTimes, choose a key and how many times execute

if(prefFirstTime.runTheFirstNTimes("anotherKey" , 5)) {
    Toast.makeText(this, "ciccia Test coutdown: "+ prefFirstTime.getCountDown("anotherKey"),
  • Use getCountDown() to better handle your code



There is support for just this in the support library revision 23.3.0 (in the v4 which means compability back to Android 1.6).

In your Launcher activity, first call:


Then call:


Which will return if this was the first time the app was launched.


If you are looking for a simple way, here it is.

Create a utility class like this,

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


At your Main Activity, onCreate()

Log.d(TAG, "First time Execution");
// do your first time execution stuff here,


Why not use the Database Helper ? This will have a nice onCreate which is only called the first time the app is started. This will help those people who want to track this after there initial app has been installed without tracking.


I like to have an “update count” in my shared preferences. If it’s not there (or default zero value) then this is my app’s “first use”.

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

So now, whenever there’s an update to the app that users should know about, I increment UPDATE_COUNT


for 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

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



     * @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()) {

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

            return new String(bytes);

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

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



Hi guys I am doing something like this. And its works for me

create a Boolean field in shared preference.Default value is true
after first time set it to false. Nothing can be simple and relaiable than this in android system.