Detectar la actualización de la aplicación Android y establecer la clase de aplicación booleana para mostrar/ocultar el EULA

Question

Estoy intentando detectar cuándo se ha actualizado mi aplicación utilizando un BroadcastReceiver y establecer un valor booleano en mi clase de aplicación. Este booleano se usará junto con algunos otros booleanos para determinar si se muestra o no el cuadro de diálogo EULA al usuario.

Creo que tengo todo configurado correctamente, pero el EULA sigue apareciendo cuando no debería. Específicamente, cuando el usuario ya ha aceptado el CLUF en una versión anterior, el CLUF no ha cambiado en la versión que se actualiza a (Establecido manualmente por mí) y la aplicación se está actualizando.

Creo que la razón por la que esto no funciona es porque mi aplicación no se está ejecutando y, por lo tanto, no se está llamando al método isAppUpgrade() y está configurando el indicador booleano correcto. ¿Alguien puede confirmar que este es el caso, o hay algo mal en mi código?

FYI - El método estático EULA.show (Activity, boolean, boolean) se está llamando lo primero en mi actividad principal.

Aquí hay un código

clase de aplicación

public class MFCApplication extends Application { 

    private boolean isUpgrade = false; 

    /** 
    * Returns a manually set value of whether the EULA has changed in this version of the App 
    * @return true/false 
    */ 
    public boolean hasEULAChanged() { 
     return false; 
    } 

    /** 
    * Returns whether or not the application has been upgraded. Set by the UpgradeBroadcastReceiver 
    * @return true/false 
    */ 
    public boolean isAppUpgrade() { 
     return isUpgrade; 
    } 

    /** 
    * Method called by UpgradeBroadcastReceiver if the App has been upgraded 
    */ 
    public void setAppIsUpgrade() { 
     this.isUpgrade = true; 
    } 
} 

BroadcastReceiver

public class UpgradeBroadcastReceiver extends BroadcastReceiver { 

    @Override 
    public void onReceive(Context context, Intent intent) { 
     if (intent == null) 
      return; 
     if (context == null) 
      return; 

     String action = intent.getAction(); 
     if (action == null) 
      return; 

     if (action.equals(Intent.ACTION_PACKAGE_REPLACED)) { 
      MFCApplication myApp = ((MFCApplication)((Activity)context).getApplication()); 

      myApp.setAppIsUpgrade(); 
     } 
    } 
} 

EULA Clase

public class EULA { 

    private static final String EULA_ASSET = "EULA"; 
    private static final String EULA_PREFERENCES = "eula"; 
    private static Activity mActivity; 

    private static PackageInfo getPackageInfo() { 
     PackageInfo pi = null; 
     try { 
      pi = mActivity.getPackageManager().getPackageInfo(mActivity.getPackageName(), PackageManager.GET_ACTIVITIES); 
     } catch (PackageManager.NameNotFoundException ex) { 
      ex.printStackTrace(); 
     } 
     return pi; 
    } 

    public static boolean show(Activity activity, boolean hasEULAChanged, boolean isAppUpgrade) { 
     mActivity = activity; 
     final SharedPreferences preferences = activity.getSharedPreferences(EULA_PREFERENCES, Activity.MODE_PRIVATE); 
     final PackageInfo packageInfo = getPackageInfo(); 
     String eulaPref = preferences.getString(EULA_PREFERENCES, "0"); 
     boolean eulaVersionAccepted = packageInfo.versionName.equals(eulaPref); 
     if (!eulaVersionAccepted && (hasEULAChanged || !isAppUpgrade)) { 
      //The EULA should be shown here, but it isn't 
      return false; 
     } 
     return true; 
    } 
} 

Manifiesto de aplicación

<receiver android:name=".helpers.UpgradeBroadcastReceiver"> 
    <intent-filter> 
     <action android:name="android.intent.action.PACKAGE_REPLACED" /> 
     <data android:scheme="package" android:path="com.hookedroid.fishingcompanion" /> 
    </intent-filter> 
</receiver> 

Answer 1

Es mucho más fácil simplemente comprobar la versión actual de la aplicación.

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

Cuando se inicia la aplicación, comprueba sus SharedPreferences para obtener un valor entero con el código de versión. Si no hay ninguno, o si no coincide, muestre el EULA. Después de que el usuario acepte el EULA, escriba el valor de versionCode en SharedPreferences.

versionCode coincidirá con el número de versión que almacena en el Manifiesto.

Answer 2

De acuerdo con el enfoque original, he gestionado para detectar si la aplicación se actualiza mediante el uso de BroadcastReceiver

public YourUpgradeReceiver extends BroadcastReceiver{ 

    @Override 
    public void onReceive(Context context, Intent intent) { 
     Uri packageName = intent.getData(); 
     if(packageName.toString().equals("package:" + context.getPackageName()){ 
      //Application was upgraded 
     } 
    } 
} 

Y en su Manifiesto

<receiver android:name=".YourUpgradeReceiver"> 
      <intent-filter> 
       <action android:name="android.intent.action.PACKAGE_REPLACED"/> 
       <data android:scheme="package"/> 
      </intent-filter> 
</receiver> 

Answer 3

detectar si la aplicación se ha actualizado

SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context); 
int versionCode = sharedPreferences.getInt("VERSION_CODE", BuildConfig.VERSION_CODE); 

if(versionCode != BuildConfig.VERSION_CODE) { 
    onAppUpdated(); 
} 

sharedPreferences.edit().putInt("VERSION_CODE", BuildConfig.VERSION_CODE).apply(); 

Answer 4

Aquí está una manera simple que tha t puede resolver su problema. En su código, puede obtener fácilmente la aplicación versionCode y versionName. En la primera instalación después de registrar GCM, guarde el versionName en sharedPreferences. En su actividad hogareña, comprueba isAppUpdated(). si la aplicación VERSION_NAME actual no coincide con VERSION_NAME almacenada, vuelva a registrar la ID de GCM.

Aquí es código de ejemplo:

Guardar VersionName en las preferencias:

public static void saveVersionNameAndCode(Context context){ 
     try{ 
      PackageInfo packageInfo = context.getPackageManager() 
        .getPackageInfo(context.getPackageName(), 0); 
      int versionCode = packageInfo.versionCode; 
      String versionName=packageInfo.versionName; 

      CommonTasks.showLog("Saving APP VersionCode and Version Name"); 

      // SAVE YOUR DATA 

     }catch(Exception e){ 
     } 
    } 

Comprobar la aplicación se actualiza:

public static boolean isAppUpdated(Context context){ 
     boolean result=false; 
     try{ 
      PackageInfo packageInfo = context.getPackageManager() 
        .getPackageInfo(context.getPackageName(), 0); 
      int versionCode = packageInfo.versionCode; 
      String versionName=packageInfo.versionName; 

      String prevVersionName= GET STORED VERSION_NAME; 
      if(prevVersionName!=null && !prevVersionName.equals("") && 
        !prevVersionName.equals(versionName)){ 
       showLog("App Updated"); 
       result=true; 
      }else{ 
       showLog("App Not updated"); 
      } 

     }catch(Exception e){ 
     } 
     return result; 
    } 

aquí, si isAppUpdated() Devuelve verdadero medio debe volver a registrar la ID de GCM.