Know when the App is first released on Android

You can use Shared Preferences to save values ​​persistently. Then you could save a variable containing the version name of the app and check it every time the app starts. Also, the Shared Preferences are maintained even after updating, so this method would also serve to detect the first execution after an update.

The idea would be that you have a constant with the version of the application (for example a String of the type "1.0.0"). And then follow an algorithm like this when starting the application:

1. Read version value in Shared Preferences (or initialize to empty string if it doesn't exist)

2. If the value of the constant is different from the value of Shared Preferences from step 1, then this is the first time the app is starting:

   • If the value in read is the empty string (""), then it is the first time after installation.
   • If it is different from the empty string, then it is the first time after an update.

3. Save the value of the constant with the version in the Shared Preferences .

Solved , taking ideas from the answers:

private int getFirstTimeRun() {
    SharedPreferences sp = getSharedPreferences("MYAPP", 0);
    int result, currentVersionCode = BuildConfig.VERSION_CODE;
    int lastVersionCode = sp.getInt("FIRSTTIMERUN", -1);
    if (lastVersionCode == -1) result = 0; else
        result = (lastVersionCode == currentVersionCode) ? 1 : 2;
    sp.edit().putInt("FIRSTTIMERUN", currentVersionCode).apply();
    return result;
}

The values ​​returned by the function:

• 0: the App has never been run.
• 1: the App has ever been run.
• 2: The App has been run at some time, but not that version.

Usage example:

switch(getFirstTimeRun()) {
    case 0:
        Log.d("appPreferences", "Es la primera vez!");
        break;
    case 1:
        Log.d("appPreferences", "ya has iniciado la app alguna vez");
        break;
    case 2:
        Log.d("appPreferences", "es una versión nueva");
}

Functionality improvements and code optimization are accepted.

EDITED

Another way is to use the Once library :

Initialize with:Once.initialise(this);

First time methods:

The first time the user installs the app:

if (!Once.beenDone(Once.THIS_APP_INSTALL, "tag")) {
    //Primera vez que se instala la app
    Once.markDone("tag");
}

The first time after app upgrade:

if (!Once.beenDone(Once.THIS_APP_VERSION, "tag")) {
    //Primera vez despues de actualizar la app
    Once.markDone("tag");
}

UPDATED APRIL 2017

There is also the possibility of obtaining if it is an installation of 0 or an update, obtaining the values ​​of the APK

public static boolean isFirstInstall(Context context) {
    try {
        long firstInstallTime =   context.getPackageManager().getPackageInfo(context.getPackageName(), 0).firstInstallTime;
        long lastUpdateTime = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).lastUpdateTime;
        return firstInstallTime == lastUpdateTime;
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
        return false;
    }
}



public static boolean isInstallFromUpdate(Context context) {
    try {
        long firstInstallTime =   context.getPackageManager().getPackageInfo(context.getPackageName(), 0).firstInstallTime;
        long lastUpdateTime = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).lastUpdateTime;
        return firstInstallTime != lastUpdateTime;
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
        return false;
    }

SharedPreferences can be used , keep in mind that these values ​​can be lost when you uninstall the app.

You can save using the method setInicia(), sending the value of 1 when it is the first installation and you can get the value of that preference using the methodgetInicia()

public static int getInicia(Context ctx){
    response = ctx.getSharedPreferences("INSTALACION", 0)
                                       .getInt("primeravez", 0);
return response;
}

public static void setInicia(Context ctx, int mode){
        ctx.getSharedPreferences("INSTALACION", 0).edit()
                                .putInt("primeravez", mode).commit();
}

However, if you want to define the first time that the application starts on a device, the method (although it is also not completely infallible) that I use is to write a file containing the string "1", inside the directory /Android/dataand not inside the directory of the app/Android/data/com.midominio.miapp

File installation = new File(getExternalInstallPath(context));
try {
    if (!installation.exists()){
        createInstallDirectory(context);                    
        writeInstallationFile(installation);                        
    }
    sID = readInstallationFile(installation);
    Log.i(TAG, "el status de la instalación es: " + sID);
} catch (Exception e) {
       Log.e(TAG, e.getMessage());
}

These are the methods used:

private static void writeInstallationFile(File installation) throws IOException {
   FileOutputStream out = new FileOutputStream(installation, false);
   String id = "1";
   Log.i(TAG, "Writing Installation File: " + id);
   out.write(id.getBytes());
   out.close();
}    

private static String readInstallationFile(File installation) throws IOException {
   RandomAccessFile f = new RandomAccessFile(installation, "r");
   byte[] bytes = new byte[(int) f.length()];
   f.readFully(bytes);
   f.close();

   return new String(bytes);
}

public static File createInstallDirectory(Context ctx) throws IOException {
   String directoryPath=getExternalInstallPath(ctx);
   File dir = new File(directoryPath);
   if (dir.exists()) {
       return dir;
   }
   if (dir.mkdirs()) {
       return dir;
   }
   throw new IOException("Failed to create INSTALL '" + directoryPath + "' for an unknown reason.");
}

public static String getExternalInstallPath(Context ctx){
   String directoryPath=Environment.getExternalStorageDirectory().getPath();
   directoryPath = directoryPath + "/Android/data/");
   return directoryPath;
}