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

numero de compilacion ya eres programador

Question

Necesito averiguar cómo obtener o hacer 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 ?

Answer 1

Usando Gradle y BuildConfig

Obteniendo el VERSION_NAME de BuildConfig

BuildConfig.VERSION_NAME

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

¿Está devolviendo una cadena vacía para VERSION_NAME?

Si BuildConfig.VERSION_NAME 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 nombre de versionName en mi archivo de compilación de Grado (migro de ANT a Gradle). Por lo tanto, aquí hay instrucciones para asegurarte de configurar tu VERSION_NAME través de Gradle.

construir.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 como ya ha configurado versionName y versionCode en el archivo build.gradle , también puede eliminarlos de su archivo AndroidManifest.xml , si están allí.

Answer 2

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 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 y cuando construya su proyecto con éxito.

{WORKSPACE} / build / genera / 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";
}

Dividir la información que necesita por script 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)

Por favor, disculpe mi capacidad limitada de inglés, pero espero que esto ayude.

Answer 3

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

Answer 4

Aquí hay una solución limpia , basada en la solución de scottyab (editada por Xavi). Muestra cómo obtener el contexto primero, si no lo proporciona su método. Además, utiliza varias líneas en lugar de llamar a múltiples métodos por línea. Esto lo hace más fácil cuando tienes que depurar tu 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);

Answer 5

Ejemplo para el 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 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

Answer 6

En el archivo de actividad

final TextView text_1 = (TextView) findViewById(R.id.text_1);
String version= BuildConfig.VERSION_NAME;
int code = BuildConfig.VERSION_CODE;
text_1.setText("version Name : "+version+ "Version Code : "+code);

Espero que te ayude...!

Answer 7

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

Answer 8

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

1. Obtener 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. BuildConfig.java desde 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 utiliza esta biblioteca. ¡ Utilízalo solo en proyectos no bibliotecarios!

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

Hay algunos detalles, excepto el uso de segunda forma en el proyecto de la biblioteca. En el nuevo plugin de Android Gradle (3.0.0+) se eliminaron algunas funcionalidades . Así que, por ahora, es decir, configurar diferentes versiones para diferentes sabores que no funcionan 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 en BuildConfig , pero de PackageManager recibirá 0 y null si no configuró la versión en la configuración default . Así que su aplicación tendrá 0 código de versión en el dispositivo.

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

Answer 9

Hay dos partes que necesitas: 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 más alto que el último.

VersionName es una cadena, y puede ser cualquier cosa 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:

Para acceder a él en código, haga 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();

Answer 10

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

Answer 11

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

Answer 12

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;

Answer 13

Si desea usarlo en xml, agregue la siguiente línea en su archivo de 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" />

Answer 14

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 el 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 here y de here .

Answer 15

Si está utilizando el complemento 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 de forma estática 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 contextual!

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

defaultConfig {
versionCode 1
versionName "1.0"
}

Answer 16

Siempre hazlo con el bloque try catch :

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

Answer 17

Una forma muy sencilla es:

private String appVersion = BuildConfig.VERSION_NAME;

Answer 18

Utilice 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"
}

Answer 19

Utilizar:

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

Y puedes obtener el código de versión usando este

int verCode = pInfo.versionCode;

Answer 20

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

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

Answer 21

prueba este

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

Answer 22

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

Answer 23

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

Answer 24

BuildConfig.VERSION_NAME //version name from your build file
BuildConfig.VERSION_CODE //version code from your build file

No veo la necesidad de obtenerlo desde el administrador de paquetes

Answer 25

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

Answer 26

try {
PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
String versionName = packageInfo.versionName;
int versionCode = packageInfo.versionCode;
//binding.tvVersionCode.setText("v" + packageInfo.versionName);
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}