¿Cómo obtener el número de compilación / versión de su aplicación Android?


Necesito averiguar cómo obtener o crear un número de compilación para mi aplicación Android. Necesito el número de compilación para mostrar en la interfaz de usuario.

¿Tengo que hacer algo con AndroidManifest.xml ?



Answers



Utilizar:

try {
    PackageInfo pInfo = this.getPackageManager().getPackageInfo(getPackageName(), 0);
    String version = pInfo.versionName;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

Y puedes obtener el código de la versión usando esto

int verCode = pInfo.versionCode;



Si está utilizando el complemento Gradle / Android Studio, a partir de la versión 0.7.0 , el código de versión y el nombre de la versión están disponibles estáticamente en BuildConfig . Asegúrese de importar el paquete de su aplicación , y no otro BuildConfig :

import com.yourpackage.BuildConfig;
...
int versionCode = BuildConfig.VERSION_CODE;
String versionName = BuildConfig.VERSION_NAME;

¡No se necesita un objeto de contexto!

También asegúrese de especificarlos en su archivo build.gradle lugar de AndroidManifest.xml .

defaultConfig {
    versionCode 1
    versionName "1.0"
}



Versión un poco más corta si solo quieres el nombre de la versión.

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



Usando Gradle y BuildConfig

Obteniendo VERSION_NAME de BuildConfig

BuildConfig.VERSION_NAME

Sí, es así de fácil ahora.

¿Devuelve una cadena vacía para VERSION_NAME?

Si está obteniendo una cadena vacía para BuildConfig.VERSION_NAME , BuildConfig.VERSION_NAME leyendo.

Seguí obteniendo una cadena vacía para BuildConfig.VERSION_NAME porque no estaba configurando el versionName en mi archivo de compilación de Grade (migré de ANT a Gradle). Por lo tanto, aquí hay instrucciones para asegurarte de que estás configurando tu VERSION_NAME través de Gradle.

build.gradle

def versionMajor = 3
def versionMinor = 0
def versionPatch = 0
def versionBuild = 0 // bump for dogfood builds, public betas, etc.

android {

  defaultConfig {
    versionCode versionMajor * 10000 + versionMinor * 1000 + versionPatch * 100 + versionBuild

    versionName "${versionMajor}.${versionMinor}.${versionPatch}"
  }

}

Nota: Esto es del magistral Jake Wharton .

Eliminando versionName y versionCode de AndroidManifest.xml

Y dado que ahora ha configurado versionName y versionCode en el archivo build.gradle , también puede eliminarlos de su archivo AndroidManifest.xml , si están allí.




Hay dos partes que necesita: android: versionCode android: versionName

versionCode es un número, y cada versión de la aplicación que envíe al Market necesita tener un número más alto que el último.

VersionName es una cadena, y puede ser lo que quieras que sea. ¡Aquí es donde defines tu aplicación como "1.0" o "2.5" o "2 Alpha EXTREME"! o lo que sea.

Ejemplo:

Para acceder al código, haz algo como:

PackageManager manager = this.getPackageManager();
PackageInfo info = manager.getPackageInfo(this.getPackageName(), 0);
Toast.makeText(this,
     "PackageName = " + info.packageName + "\nVersionCode = "
       + info.versionCode + "\nVersionName = "
       + info.versionName + "\nPermissions = " + info.permissions, Toast.LENGTH_SHORT).show();



Aquí hay una solución limpia , basada en la solución de scottyab (editado por Xavi). Muestra cómo obtener el contexto primero, si su método no lo proporciona. Además, utiliza múltiples líneas en lugar de llamar a múltiples métodos por línea. Esto hace que sea más fácil cuando tiene que depurar su aplicación.

Context context = getApplicationContext(); // or activity.getApplicationContext()
PackageManager packageManager = context.getPackageManager();
String packageName = context.getPackageName();

String myVersionName = "not available"; // initialize String

try {
    myVersionName = packageManager.getPackageInfo(packageName, 0).versionName;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

Ahora que recibió el nombre de la versión en el String myVersionName , puede configurarlo en un TextView o lo que quiera.

// set version name to a TextView
TextView tvVersionName = (TextView) findViewById(R.id.tv_versionName);
tvVersionName.setText(myVersionName);



Si usa PhoneGap, cree un plugin PhoneGap personalizado:

Crea una nueva clase en el paquete de tu aplicación:

package com.Demo; //replace with your package name

import org.json.JSONArray;

import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;

import com.phonegap.api.Plugin;
import com.phonegap.api.PluginResult;
import com.phonegap.api.PluginResult.Status;

public class PackageManagerPlugin extends Plugin {

    public final String ACTION_GET_VERSION_NAME = "GetVersionName";

    @Override
    public PluginResult execute(String action, JSONArray args, String callbackId) {
        PluginResult result = new PluginResult(Status.INVALID_ACTION);
        PackageManager packageManager = this.ctx.getPackageManager();

        if(action.equals(ACTION_GET_VERSION_NAME)) {
            try {
                PackageInfo packageInfo = packageManager.getPackageInfo(
                                              this.ctx.getPackageName(), 0);
                result = new PluginResult(Status.OK, packageInfo.versionName);
            }
            catch (NameNotFoundException nnfe) {
                result = new PluginResult(Status.ERROR, nnfe.getMessage());
            }
        }

        return result;
    }
}

En plugins.xml, agregue la siguiente línea:

<plugin name="PackageManagerPlugin" value="com.Demo.PackageManagerPlugin" />

En su evento deviceready , agregue el siguiente código:

var PackageManagerPlugin = function() {

};
PackageManagerPlugin.prototype.getVersionName = function(successCallback, failureCallback) {
    return PhoneGap.exec(successCallback, failureCallback, 'PackageManagerPlugin', 'GetVersionName', []);
};
PhoneGap.addConstructor(function() {
    PhoneGap.addPlugin('packageManager', new PackageManagerPlugin());
});

Luego, puede obtener el atributo versionName haciendo:

window.plugins.packageManager.getVersionName(
    function(versionName) {
        //do something with versionName
    },
    function(errorMessage) {
        //do something with errorMessage
    }
);

Derivado de aquí y aquí .




Una forma muy simple es:

private String appVersion = BuildConfig.VERSION_NAME;



Siempre hazlo con try catch block:

String versionName = "Version not found";

try {
    versionName = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
    Log.i(TAG, "Version Name: " + versionName);
} catch (NameNotFoundException e) {
    // TODO Auto-generated catch block
    Log.e(TAG, "Exception Version Name: " + e.getLocalizedMessage());
}



Aquí está el método para obtener el código de la versión:

public String getAppVersion() {
    String versionCode = "1.0";
    try {
        versionCode = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;
    } catch (PackageManager.NameNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return versionCode;
}



HE SOLVE esto usando la clase Preference.

package com.example.android;

import android.content.Context;
import android.preference.Preference;
import android.util.AttributeSet;

public class VersionPreference extends Preference {
    public VersionPreference(Context context, AttributeSet attrs) {
        super(context, attrs);
        String versionName;
        final PackageManager packageManager = context.getPackageManager();
        if (packageManager != null) {
            try {
                PackageInfo packageInfo = packageManager.getPackageInfo(context.getPackageName(), 0);
                versionName = packageInfo.versionName;
            } catch (PackageManager.NameNotFoundException e) {
                versionName = null;
            }
            setSummary(versionName);
        }
    }
}



Para usuarios de xamarin, utiliza este código para obtener el nombre y el código de la versión

1) Nombre de la versión:

public string getVersionName(){
      return Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0).VersionName;
}

2) Código de versión:

public string getVersionCode(){
      return Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0).VersionCode;
}



Si desea usarlo en xml, agregue la siguiente línea en su archivo gradle:

applicationVariants.all { variant ->
    variant.resValue "string", "versionName", variant.versionName
}

Y luego úsalo en tu xml así:

<TextView
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/versionName" />



Alguien que no necesita información de BuildConfig para la interfaz de usuario de la aplicación, sin embargo, quiere usar esta información para establecer una configuración de trabajo de CI u otros, como yo.

Hay un archivo generado automáticamente, BuildConfig.java, debajo del directorio de su proyecto, siempre que construya su proyecto con éxito.

{WORKSPACE} / build / generated / source / buildConfig / {debug | release} / {PACKAGE} /BuildConfig.java

/**
* Automatically generated file. DO NOT MODIFY
*/
package com.XXX.Project;

public final class BuildConfig {
    public static final boolean DEBUG = Boolean.parseBoolean("true");
    public static final String APPLICATION_ID = "com.XXX.Project";
    public static final String BUILD_TYPE = "debug";
    public static final String FLAVOR = "";
    public static final int VERSION_CODE = 1;
    public static final String VERSION_NAME = "1.0.0";
}

Divida la información que necesita mediante la secuencia de comandos python u otras herramientas. Aquí hay un ejemplo:

import subprocess
#find your BuildConfig.java
_BuildConfig = subprocess.check_output('find {WORKSPACE} -name BuildConfig.java', shell=True).rstrip()
#get the version name
_Android_version = subprocess.check_output('grep -n "VERSION_NAME" '+_BuildConfig, shell=True).split('"')[1]
print('Android version :’+_Android_version)

Disculpe mi capacidad limitada de inglés, pero espero que esto ayude.




Este código fue mencionado anteriormente en partes, pero aquí está de nuevo todo incluido. Necesita un bloque try / catch porque puede arrojar una "NameNotFoundException".

try {
   String appVersion = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;
} catch (PackageManager.NameNotFoundException e) {e.printStackTrace();}

Espero que esto simplifique las cosas para alguien en el futuro. :)




 package com.sqisland.android.versionview;

import android.app.Activity;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends Activity {
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    TextView textViewversionName = (TextView) findViewById(R.id.text);

    try {
        PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
        textViewversionName.setText(packageInfo.versionName);

    }
    catch (PackageManager.NameNotFoundException e) {

    }

  }
}



Primero:

import android.content.pm.PackageManager.NameNotFoundException;

y luego usa esto:

PackageInfo pInfo = null;
try {
     pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
} catch (NameNotFoundException e) {
     e.printStackTrace();
            }
String versionName = pInfo.versionName;



private String GetAppVersion(){
        try {
            PackageInfo _info = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            return _info.versionName;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return "";
        }
    }

    private int GetVersionCode(){
        try {
            PackageInfo _info = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            return _info.versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return -1;
        }
    }



prueba este:

try 
{
    device_version =  getPackageManager().getPackageInfo("com.google.android.gms", 0).versionName;
}
catch (PackageManager.NameNotFoundException e)
{
    e.printStackTrace();
}



Ejemplo para el uso interno de Fragmentos.

        import android.content.pm.PackageManager;
        .......

        private String VersionName;
        private String VersionCode;
        .......


        Context context = getActivity().getApplicationContext();

        /*Getting Application Version Name and Code*/
        try
        {

             VersionName = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;

             /*I find usefull to convert vervion code into String, so it's ready for TextViev/server side checks*/ 

             VersionCode = Integer.toString(context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode);
        } catch (PackageManager.NameNotFoundException e)
        {
             e.printStackTrace();
        }

// DO SOMETHING USEFULL WITH THAT



Hay algunas maneras de obtener versionCode y versionName programación.

  1. Obtenga la versión de PackageManager . Esta es la mejor manera para la mayoría de los casos.
try {
    String versionName = packageManager.getPackageInfo(packageName, 0).versionName;
    int versionCode = packageManager.getPackageInfo(packageName, 0).versionCode;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}
  1. BuildConfig.java generado. Pero tenga en cuenta que si accede a estos valores en la biblioteca, devolverá la versión de la biblioteca, no las aplicaciones, que usa esta biblioteca. ¡Así que use solo en proyectos que no sean de biblioteca!
String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;

Hay algunos detalles, excepto el uso de la segunda vía en el proyecto de la biblioteca. En el nuevo complemento android gradle (3.0.0+) se eliminaron algunas funcionalidades . Por lo tanto, por ahora, es decir, la configuración de diferentes versiones para diferentes sabores no funciona correctamente.

Forma incorrecta:

applicationVariants.all { variant ->
    println('variantApp: ' + variant.getName())

    def versionCode = {SOME_GENERATED_VALUE_IE_TIMESTAMP}
    def versionName = {SOME_GENERATED_VALUE_IE_TIMESTAMP}

    variant.mergedFlavor.versionCode = versionCode
    variant.mergedFlavor.versionName = versionName
}

El código anterior configurará correctamente los valores en BuildConfig , pero desde PackageManager recibirás 0 y null si no configuraste la versión en la configuración default . Entonces, tu aplicación tendrá 0 código de versión en el dispositivo.

Hay una solución: configure la versión para el archivo apk salida manualmente:

applicationVariants.all { variant ->
    println('variantApp: ' + variant.getName())

    def versionCode = {SOME_GENERATED_VALUE_IE_TIMESTAMP}
    def versionName = {SOME_GENERATED_VALUE_IE_TIMESTAMP}

    variant.outputs.all { output ->
        output.versionCodeOverride = versionCode
        output.versionNameOverride = versionName
    }
}