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

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

¿Tengo que hacer algo con AndroidManifest.xml?

Utilizar:

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

Y puede obtener el código de 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 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.gradlearchivo en 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;

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 debe tener un número mayor que el anterior.

VersionName es una cadena y puede ser lo que quieras que sea. 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

Obteniendo el 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 seguir BuildConfig.VERSION_NAMEleyendo.

Seguí obteniendo una cadena vacía BuildConfig.VERSION_NAMEporque no estaba configurando versionNameen mi archivo de compilación de Grade (migré de ANT a Gradle). Entonces, aquí hay instrucciones para asegurarse de que está configurando su VERSION_NAMEvía 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 .

Eliminar versionNamey versionCodedeAndroidManifest.xml

Y dado que ha configurado el versionNamey versionCodeen el build.gradlearchivo ahora, también puede eliminarlos de su AndroidManifest.xmlarchivo, si están allí.

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 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 establecerlo en TextView o lo que quiera.

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

Para obtener la versión de la aplicación o el código de compilación que se utiliza para identificar el apk por su código de versión. El código de 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 usa 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;

Use la clase BuildConfig

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

build.gradle (aplicación)

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

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 de dispositivo listo , 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 de aquí .

Kotlin one-liners

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

Asegúrate de importar BuildConfiga tu clase

Para usuarios de xamarin, 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;
}

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" />

No, no necesitas hacer nada con AndroidManifest.xml

Básicamente, el nombre y el código de la versión de su aplicación dentro del archivo gradle de nivel de aplicación , bajo la etiqueta de configuración predeterminada :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

Nota: Cuando desee cargar la 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 del código de la versión actual si esta aplicación ya está en Play Store.

Simplemente use el siguiente fragmento de código para obtener el código y el 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();  
}  

para Api 28, 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";
    }

Hazlo siempre con try catchbloque:

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 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 usando la clase de preferencia.

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 obtener versionCodey mediante versionNameprogramació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();
}

2. Consíguelo desde generado BuildConfig.java. 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. ¡ Ú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 vía en el proyecto de biblioteca. En el nuevo complemento de Android Gradle (3.0.0+) algunos eliminaron funcionalidades . Entonces, por ahora, es decir, configurar 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 establecerá correctamente los valores BuildConfig, pero PackageManagerrecibirá 0ynull si no configuraste la versión en la defaultconfiguración. Entonces su aplicación tendrá un 0código de versión en el dispositivo.

Hay una solución alternativa: establecer la versión para el apkarchivo de 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
    }
}

Este código se mencionó anteriormente en partes, pero aquí está nuevamente 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. :)

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

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

{ESPACIO DE TRABAJO} / build / generado / 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 por script de 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 limitada capacidad de inglés, pero espero que esto ayude.

 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 para uso interno de Fragment.

        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

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

No agradezcas :-)

  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 versión y verificar si la aplicación está 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)
{

    final String appPackageName = context.getPackageName(); // getPackageName() from Context or Activity object
    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 versión usando preferencia compartida 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 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 default  version code is 0
     }
   }

Como en 2020: API 28 "versionCode" está en desuso, por lo que podemos 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
        }

Útil para los sistemas de compilación: hay un archivo generado con su apk llamado output.jsonque contiene una matriz de información para cada APK generado, incluidos versionName y versionCode.

p.ej

[
    {
        "apkInfo": {
            "baseName": "x86-release",
            "enabled": true,
            "filterName": "x86",
            "fullName": "86Release",
            "outputFile": "x86-release-1.0.apk",
            "splits": [
                {
                    "filterType": "ABI",
                    "value": "x86"
                }
            ],
            "type": "FULL_SPLIT",
            "versionCode": 42,
            "versionName": "1.0"
        },
        "outputType": {
            "type": "APK"
        },
        "path": "app-x86-release-1.0.apk",
        "properties": {}
    }
]