Determine if Android app is being used for the first time

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.

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

It could be used from an activity like this:

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

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

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!

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

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

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.

Here's some code for this -

String path = Environment.getExternalStorageDirectory().getAbsolutePath() +
					"/Android/data/myapp/files/myfile.txt";
					
boolean exists = (new File(path)).exists(); 
				   
if (!exists) {
    doSomething();										
}
else {
	doSomethingElse();
}

You can use Android SharedPreferences .

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

CODE

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

}

Now Open Your Activity & Initialize .

 private     SharedPreference                sharedPreferenceObj; // Declare Global

Now Call this in OnCreate section

 sharedPreferenceObj=new SharedPreference(YourActivity.this);

Now Checking

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
 }

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

e.g.

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

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:

AppLaunchChecker.onActivityCreate(activity);

Then call:

AppLaunchChecker.hasStartedFromLauncher(activity);

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

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

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

Example

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"),
                   Toast.LENGTH_LONG).show();
}

Use runTheFirstNTimes, choose a key and how many times execute

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

• Use getCountDown() to better handle your code

FirstTimePreference.java

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

}

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

My version for kotlin looks like the following:

PreferenceManager.getDefaultSharedPreferences(this).apply {
        // Check if we need to display our OnboardingSupportFragment
        if (!getBoolean("wasAppStartedPreviously", false)) {
            // The user hasn't seen the OnboardingSupportFragment yet, so show it
            startActivity(Intent(this@SplashScreenActivity, AppIntroActivity::class.java))
        } else {
            startActivity(Intent(this@SplashScreenActivity, MainActivity::class.java))
        }
    }

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

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

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