tengo - Detectar si hay nueva instalación o versión actualizada(aplicación de Android)

se cayo twitter hoy 2018

Question

Tengo una aplicación en la Play Store. Quiero poner el requisito de que si los usuarios quieren usar una parte determinada de la aplicación, tienen que invitar a un amigo antes de poder hacerlo. Pero solo quiero imponer esta restricción a las nuevas instalaciones de la aplicación (para ser justos con los usuarios que han instalado la aplicación antes de la restricción). Perdón por la introducción larga, mi pregunta es ¿cómo puedo saber si el dispositivo actual ha actualizado la aplicación o es una nueva instalación?

Answer 1

Actualizar

(Gracias por los comentarios debajo de mi respuesta por pedir una respuesta más específica / completa).

Debido a que realmente no puede cambiar retroactivamente el código de las versiones anteriores de su aplicación, creo que lo más fácil es permitir que todas las instalaciones actuales sean excluidas.

Entonces, para hacer un seguimiento de eso, una forma sería encontrar información que apunte a una versión específica de su aplicación. Ya sea que se SharedPreferences un archivo con marca de tiempo, un SharedPreferences o incluso el SharedPreferences versionCode (como lo sugiere @DaudArfin en su respuesta) de la última versión de la aplicación que desea que los usuarios no tengan esta restricción. Entonces necesitas cambiar esto. Ese cambio se convierte en su punto de referencia para todas las instalaciones anteriores. Para aquellos usuarios, marque su marca "has_shared" como verdadera. Se convierten en derechos adquiridos. Luego, en el futuro, puede establecer el "has_shared" predeterminado "has_shared" en true

(Original, respuesta parcial abajo)

Use un SharedPrefence (o similar)

Use algo como SharedPreferences . De esta manera, puede poner un valor simple como has_shared = true y SharedPreferences persistirá a través de las actualizaciones de la aplicación.

Algo así cuando han firmado a alguien / han compartido tu aplicación.

SharedPreferences prefs = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = prefs.edit();
editor.putBoolean("has_shared", true)
editor.commit();

Entonces solo puedes molestar a la gente cuando el pref devuelve true

SharedPreferences prefs = getActivity().getPreferences(Context.MODE_PRIVATE);
boolean defaultValue = false;
boolean hasShared= prefs.gettBoolean("has_shared", defaultValue);
if (!hasShared) {
    askUserToShare();
}

Docs para SharedPreference:
http://developer.android.com/training/basics/data-storage/shared-preferences.html

Answer 2

Compruebe si la versión anterior de su aplicación guarda algunos datos en el disco o las preferencias. Estos datos deben ser seguros, es decir, no pueden ser eliminados por el usuario (no estoy seguro de que sea posible).

Cuando la nueva versión esté recién instalada, estos datos no existirán. Si la nueva versión es una actualización de la versión anterior, estos datos existirán.

En el peor de los casos, un usuario antiguo se marcará como nuevo y tendrá un uso restringido.

Answer 3

La única solución que puedo ver que no involucra a una entidad fuera del dispositivo sería obtener el PackageInfo para su aplicación y verificar los valores de

• versionCode
• firstInstallTime
• lastUpdateTime

En la primera instalación, firstInstallTime y lastUpdateTime tendrán el mismo valor (al menos en mi dispositivo eran iguales); después de una actualización, los valores serán diferentes porque cambiará lastUpdateTime . Además, sabe aproximadamente en qué fecha y hora crea la versión que presenta este nuevo comportamiento, y también sabe qué código de versión tendrá.

Extendería la Application e implementaría esta verificación en onCreate() y almacenaría el resultado en SharedPreferences :

public class MyApplication extends Application {

    // take the date and convert it to a timestamp. this is just an example.
    private static final long MIN_FIRST_INSTALL_TIME = 1413267061000L;
    // shared preferences key
    private static final String PREF_SHARE_REQUIRED = "pref_share_required";

    @Override
    public void onCreate() {
        super.onCreate();
        checkAndSaveInstallInfo();
    }

    private void checkAndSaveInstallInfo() {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
        if (prefs.contains(PREF_SHARE_REQUIRED)) {
            // already have this info, so do nothing
            return;
        }

        PackageInfo info = null;
        try {
            info = getPackageManager().getPackageInfo(getPackageName(), 0);
        } catch (NameNotFoundException e) {
            // bad times
            Log.e("MyApplication", "couldn''t get package info!");
        }

        if (packageInfo == null) {
            // can''t do anything
            return;
        }

        boolean shareRequired = true;
        if (MIN_FIRST_INSTALL_TIME > info.firstInstallTime
                && info.firstInstallTime != info.lastUpdateTime) {
            /*
             * install occurred before a version with this behavior was released
             * and there was an update, so assume it''s a legacy user
             */
            shareRequired = false;
        }
        prefs.edit().putBoolean(PREF_SHARE_REQUIRED, shareRequired).apply();
    }
}

Esto no es infalible, hay formas de evitarlo si el usuario realmente lo desea, pero creo que es lo mejor que se puede conseguir. Si desea realizar un seguimiento de estas cosas mejor y evitar la manipulación por parte del usuario, debe comenzar a almacenar la información del usuario en un servidor (suponiendo que tenga algún tipo de servidor).

Answer 4

Mi solución es utilizar SahredPreference.

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

Devuelve 3 valores posibles:

• 0: La aplicación es la primera instalación
• 1: la aplicación se ejecuta una vez
• 2: La aplicación está actualizada

Answer 5

Puede obtener el código de la versión y el nombre de la versión usando el siguiente fragmento de código

String versionName = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;

int versionCode = getPackageManager().getPackageInfo(getPackageName(), 0).versionCode;

Ahora puede verificar la última versión y restringir según sus requerimientos.

Answer 6

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



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