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

Uso:

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

Y puede obtener el código de la versión usando este

int verCode = pInfo.versionCode;

Si está utilizando el complemento de Gradle / Android Studio, a partir de la versión 0.7.0, el código de la 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 ningún objeto de contexto!

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

defaultConfig {
    versionCode 1
    versionName "1.0"
}

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

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

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 mercado debe tener un número más alto que la anterior.

VersionName es una cadena y puede ser cualquier cosa que desee. Aquí es donde define su aplicación como "1.0" o "2.5" o "2 Alpha EXTREME!" o lo que sea.

Ejemplo:

Kotlin:

val manager = this.packageManager
val info = manager.getPackageInfo(this.packageName, PackageManager.GET_ACTIVITIES)
toast("PackageName = " + info.packageName + "\nVersionCode = "
            + info.versionCode + "\nVersionName = "
            + info.versionName + "\nPermissions = " + info.permissions)

Java:

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

Usando Gradle y BuildConfig

Obtener VERSION_NAME de BuildConfig

BuildConfig.VERSION_NAME

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

¿Devuelve una cadena vacía para VERSION_NAME?

Si obtiene una cadena vacía para BuildConfig.VERSION_NAME luego sigue leyendo.

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

Declarar impuestos 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 warton.

Extracción versionName y versionCode a partir de octubre XNUMX AndroidManifest.xml

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

Aquí hay una solución limpia, Basado 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 varias líneas en lugar de llamar a varios métodos por línea. Esto lo hace 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 la cadena myVersionName, puede configurarlo en un TextView o lo que quiera.

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

Utilice lo siguiente para obtener la versión de la aplicación o el código de compilación que se utiliza para identificar el archivo APK por su código de versión. El código de la versión se utiliza para detectar la configuración de compilación real en el momento de la actualización, publicación, etc.

int versionCode = BuildConfig.VERSION_CODE;

El nombre de la versión se utiliza para mostrar a los usuarios o desarrolladores de la secuencia de desarrollo. Puede agregar cualquier tipo de nombre de versión que desee.

String versionName = BuildConfig.VERSION_NAME;

Utilice la clase BuildConfig:

String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;

Declarar impuestos build.gradle (aplicación)

defaultConfig {
    applicationId "com.myapp"
    minSdkVersion 19
    targetSdkVersion 27
    versionCode 17
    versionName "1.0"
}

Kotlin de una sola línea

val versionCode = BuildConfig.VERSION_CODE
val versionName = BuildConfig.VERSION_NAME

Asegúrate de importar BuildConfig en tu clase.

Conceptos básicos de Java

String versionCode = String.valueOf(BuildConfig.VERSION_CODE);
String versionName = String.valueOf(BuildConfig.VERSION_NAME);

Si está utilizando PhoneGap, cree un complemento 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í.

Como en 2020: A partir de API 28 (Android 9 (Tarta)), "versionCode" está obsoleto para que podamos usar "longVersionCode".

Código de muestra en Kotlin

val manager = context?.packageManager
val info = manager?.getPackageInfo(
    context?.packageName, 0
)

val versionName = info?.versionName
val versionNumber = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                        info?.longVersionCode
                    } else {
                        info?.versionCode
                    }

Para API 28 (Android 9 (Pie)), PackageInfo.versionCode está en desuso, así que use este código a continuación:

Context context = getApplicationContext();
PackageManager manager = context.getPackageManager();
try {
    PackageInfo info = manager.getPackageInfo(context.getPackageName(), 0);
    myversionName = info.versionName;
    versionCode = (int) PackageInfoCompat.getLongVersionCode(info);
}
catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
    myversionName = "Unknown-01";
}

Si desea usarlo en contenido XML, agregue la siguiente línea en su archivo Gradle:

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

Y luego úselo en su contenido XML de esta manera:

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

Para Xamarin usuarios, use 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;
    }
   

No, no necesita hacer nada con AndroidManifest.xml

Básicamente, el nombre de la versión de su aplicación y el código de la versión están dentro del nivel de aplicación Gradle archivo, debajo configuración por defecto tag:

defaultConfig {
   versionCode 1
   versionName "1.0"
}

Nota: Cuando desee cargar una aplicación en la tienda de juegos, puede dar cualquier nombre como nombre de la versión, pero el código de la versión debe ser diferente al código de la versión actual si esta aplicación ya está en la tienda de juegos.

Simplemente use el siguiente fragmento de código para obtener el código de versión & nombre de la versión desde cualquier lugar de su aplicación:

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

Hazlo siempre con un try catch bloque:

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

Este es 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 resuelto esto mediante el uso de 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);
        }
    }
}

Hay algunas formas de conseguir versionCode y versionName programáticamente.

1. Obtener la versión de PackageManager. Esta es la mejor forma 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();
    }
   

2. Consígalo de generado BuildConfig.java. Pero tenga en cuenta que si accede a estos valores en la biblioteca, devolverá la versión de la biblioteca, no la de las aplicaciones, que usa esta biblioteca. Entonces ¡Úselo 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 forma en el proyecto de la biblioteca. En el nuevo complemento de Android Gradle (3.0.0+) algunos funcionalidades eliminadas. Entonces, por ahora, es decir, configurar una versión diferente para diferentes sabores no funciona correctamente.

Manera 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 establecerá correctamente los valores en BuildConfig, Pero de donde PackageManager recibirás 0 y null si no estableciste la versión en default configuración. Entonces tu aplicación tendrá 0 código de versión en el dispositivo.

Hay una solución alternativa: configurar la versión para la salida apk archivo 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
    }
}

nombre de la versión: BuildConfig.VERSION_NAME código de la versión: BuildConfig.VERSION_CODE

Este código se mencionó anteriormente en partes, pero aquí está nuevamente todo incluido. Necesita un bloque try / catch, porque puede lanzar 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. :)

Para alguien que no necesita la información de BuildConfig para la interfaz de usuario de la aplicación, sin embargo, quiere usar esta información para configurar un CI configuración de trabajo u otros, como yo:

Hay un archivo generado automáticamente, BuildConfig.java, en el directorio de su proyecto siempre que lo construya correctamente.

{ESPACIO DE TRABAJO} / build / generate / 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 un script de Python u otras herramientas. He aquí 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)

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

    }
  }
}

Prueba este:

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

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

Ejemplo de uso de Fragmentos internos.

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 it useful 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 useful with that

Ejemplo de Kotlin:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.act_signin)

    packageManager.getPackageInfo(packageName, PackageManager.GET_ACTIVITIES).apply {
        findViewById<TextView>(R.id.text_version_name).text = versionName
        findViewById<TextView>(R.id.text_version_code).text =
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) "$longVersionCode" else "$versionCode"
    }

    packageManager.getApplicationInfo(packageName, 0).apply{
        findViewById<TextView>(R.id.text_build_date).text =
            SimpleDateFormat("yy-MM-dd hh:mm").format(java.io.File(sourceDir).lastModified())
    }
}

PackageInfo pinfo = null;
try {
    pinfo = getPackageManager().getPackageInfo(getPackageName(), 0);
}
catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}
int versionNumber = pinfo.versionCode;
String versionName = pinfo.versionName;

Como tenía que obtener solo el código de la versión y verificar si la aplicación estaba actualizada o no, en caso afirmativo, tuve que iniciar la tienda de juegos para actualizarla. Lo hice de esta manera.

public class CheckForUpdate {

    public static final String ACTION_APP_VERSION_CHECK = "app-version-check";

    public static void launchPlayStoreApp(Context context)
    {
        // getPackageName() from Context or Activity object
        final String appPackageName = context.getPackageName();
        try {
            context.startActivity(new Intent(Intent.ACTION_VIEW,
                                  Uri.parse("market://details?id=" + appPackageName)));
        }
        catch (android.content.ActivityNotFoundException anfe) {
            context.startActivity(new Intent(Intent.ACTION_VIEW,
                                  Uri.parse("https://play.google.com/store/apps/details?id=" +
                                             appPackageName)));
        }
    }

    public static int getRemoteVersionNumber(Context context)
    {
        int versionCode = 0;
        try {
            PackageInfo pInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
            String version = pInfo.versionName;
            versionCode = pInfo.versionCode;
        }
        catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return versionCode;
    }

}

Luego guardé el código de la versión usando preferencias compartidas creando una clase util.

public class PreferenceUtils {

    // This is for version code
    private  final String APP_VERSION_CODE = "APP_VERSION_CODE";
    private  SharedPreferences sharedPreferencesAppVersionCode;
    private SharedPreferences.Editor editorAppVersionCode;
    private static Context mContext;

    public PreferenceUtils(Context context)
    {
        this.mContext = context;
        // This is for the app versioncode
        sharedPreferencesAppVersionCode = mContext.getSharedPreferences(APP_VERSION_CODE,MODE_PRIVATE);
        editorAppVersionCode = sharedPreferencesAppVersionCode.edit();
    }

    public void createAppVersionCode(int versionCode) {

        editorAppVersionCode.putInt(APP_VERSION_CODE, versionCode);
        editorAppVersionCode.apply();
    }

    public int getAppVersionCode()
    {
        return sharedPreferencesAppVersionCode.getInt(APP_VERSION_CODE,0); // As the default version code is 0
    }
}