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

1289

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?

Fahad Ali Shaikh
fuente
2
No estoy seguro, pero creo que puede obtenerlo al analizar el archivo AndroidManifest.xml.
Sunit Kumar Gupta
Para obtener el código de la versión, use int versionCode = BuildConfig.VERSION_CODE;y para obtener el nombre de la versiónString versionName = BuildConfig.VERSION_NAME;
Lukas

Respuestas:

2041

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;
más-
fuente
52
@Felix no puede llamar a getPackageManager () fuera del contexto, por lo que puede ser necesario getApplicationContext () (o contexto pasado).
Sver
2
¿Qué pasa si necesita este número dentro de algún método estático donde no puede pasar el contexto? mal diseño de mi parte?
Gubatron
35
Y no olvides try... catch..cuándogetPackageInfo()
anticafe
44
@Gubatron mi respuesta a continuación permite recuperar estos valores estáticamente.
Sam Dozor
25
Si solo desea obtener la versión de la aplicación, esto es dos complicados. Debe usar BuildConfig.VERSION_**como se sugiere aquí .
Timo Bähr
1921

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"
}
Sam Dozor
fuente
178
En realidad, esto es mucho mejor que todo el contexto y el administrador de paquetes, gracias.
superjugy
16
En realidad, esta es la mejor solución después del lanzamiento de Android Studio. +1 de mi lado
Dhruvil Patel
15
No es muy confiable. El nombre de la versión aparece como una cadena vacía la mayor parte del tiempo.
Binoy Babu
20
@BinoyBabu nunca debería aparecer como una cadena vacía si ha especificado una versionNamepara su aplicación en su build.gradlearchivo.
Sam Dozor
39
Tendrá que importar el paquete correcto para que esto funcione:import com.yourapppackage.android.BuildConfig
Eric B.
438

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;
scottyab
fuente
81
Excelente. Esto probablemente debería estar rodeado de try / catch para NameNotFoundException.
IgorGanapolsky
66
+1 ¡He implementado tu solución que funciona muy bien! Sin embargo, esta solución debe estar rodeada por try and catch como dijo Igor Y es una buena práctica (por ejemplo, para la depuración) colocar cada llamada de método en una línea separada en lugar de llamar a context.methodName (). SubMethod (). AnotherSubMethod () etc. .en una sola línea. Por lo tanto, proporcioné una solución más limpia a continuación
Michael
1
Esa es la solución correcta, gracias;) Pero, como lo sugiere @IgorGanapolsky, debe estar rodeado de try / catch :)
andrea.rinaldi
2
Para aquellos que usan Gradle, existe una solución más simple. Vea mi respuesta a continuación.
Sam Dozor
1
@ Erwinus Estoy totalmente en desacuerdo con la idea de usar una excepción genérica para atrapar cosas como esta. Excepciones más precisas demuestran la comprensión de un desarrollador de posibles errores.
IgorGanapolsky
174

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();
Merkidemis
fuente
66
Descripción oficial de Android android:versionCodey android:versionNamese puede encontrar aquí: developer.android.com/tools/publishing/...
Jeffro
2
esto en este caso es Contexto .ie Actividad, Servicio .etc
peterchaula
3
cuando pega algún código de muestra es útil para explicar el significado de los parámetros ... aunque todo el mundo puede entender lo que this.getPackageName()representa lo 0que acaba de escupir no tiene idea sobre el significado
Rafael Lima
Android Studio afirma que
el código de
1
@RomanGherta Es a partir de la API 28. Si está escribiendo código usando algo menos (o hace 8 años cuando se escribió esta respuesta) aún debería estar listo. Otra respuesta aquí tiene el método actualizado.
Merkidemis
146

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í.

Joshua Pinter
fuente
55
Esto funciona muy bien siempre que acceda a BuildConfig desde el proyecto de la aplicación, no a una biblioteca utilizada en el proyecto de la aplicación. De lo contrario, obtendrá BuildConfig para el proyecto de biblioteca, no la aplicación.
John Cummings
@JohnCummings Interesante ... no pensé en eso.
Joshua Pinter
No funciona en absoluto versionName "1.2", y BuildConfig.VERSION_NAMEregreso empty. API> 21
Sojtin
Como seguimiento, en realidad dejamos de usar este método en favor de solo un entero estático y una cadena estática para el versionCodey versionName, respectivamente. Solo porque algunas herramientas como Code Push intentan obtener su número de versión analizando su build.gradlearchivo y no pueden completar un valor dinámico.
Joshua Pinter
@JoshuaPinter PackageManager es realmente la opción más segura. Si usa modificaciones de código de versión para divisiones, la constante BuildConfig aún conserva el valor original (aunque con sabor).
Eugen Pechanec
54

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);
Miguel
fuente
¿Crees que NNFE puede ser realmente arrojado? Sería extraño no encontrar una aplicación en ejecución en el administrador de paquetes :)
TWiStErRob
Estoy con ustedes para que pueda ser extraño, pero es la excepción predeterminada de este método; vea API : dice Throws PackageManager.NameNotFoundException if a package with the given name can not be found on the system.. Sin embargo, ¡no podría imaginarme un escenario para eso!
Michael
38

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;
Rohit Patil
fuente
34

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"
   }
Velayutham M
fuente
23

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í .

Sean Hall
fuente
99
La pregunta no era sobre PhoneGap. Tu respuesta podría confundir a la gente.
likebobby
8
@BobbyJ En ninguna parte de la pregunta, título o etiquetas se especifica que la pregunta era sobre una aplicación nativa. Esto es lo que surgió en Google cuando estaba buscando la respuesta, y me habría ahorrado varias horas.
Sean Hall
Gracias Hall72215. Me alegraré de esto ... si realmente no hay otra forma de obtener su propio número de versión ¡Prefiero evitar un complemento si es posible!
Magnus Smith
@MagnusSmith No, a menos que PhoneGap / Cordova lo haya agregado a sus funciones integradas.
Sean Hall
En este ejemplo, puede ver lo tonto que es usar soluciones de terceros para crear aplicaciones. Cuando lo escribiste tú mismo desde cero, solo fueron un par de líneas para codificar.
Codebeat
19

Kotlin one-liners

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

Asegúrate de importar BuildConfiga tu clase

Gastón Saillén
fuente
13

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;
}
Tushar patel
fuente
12

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" />
Irfan Raza
fuente
Recibo en mi xml el error: No se puede resolver el símbolo '@ string / versionName'
RJB
12

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();  
}  
Monir Zzaman
fuente
1
versionCode quedó en desuso en la API 28. Como se indica en los documentos, use longVersionCode en su lugar; developer.android.com/reference/android/content/pm/…
Dan Abnormal
11

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";
    }
Amir jodat
fuente
9

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());
}
Pratik Butani
fuente
9

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;
}
Gevaria Purva
fuente
3
Mejor método - BuildConfig.VERSION_CODE
Jaydev
8

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);
        }
    }
}
Shubham Gupta
fuente
8

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();
}
  1. 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
    }
}
mohax
fuente
6

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. :)

Jeff.H
fuente
5

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.

JasonChiu
fuente
4
 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) {

    }

  }
}
Durul Dalkanat
fuente
Hola @donmj. Si está utilizando una raíz oficial para un dispositivo Android. Creo que lo necesitarás. Este es mi enfoque.
Durul Dalkanat
Gracias por la ayuda @Durul Dalkanat :).
donmj
4

prueba este:

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

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;
meduvigo
fuente
1
No hay cuerpo que tenga tiempo para eso.
BlaShadow
3
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;
        }
    }
Atif Mahmood
fuente
3

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
Zafiro91140
fuente
Debe mirar otras respuestas antes de publicar su respuesta. por ejemplo, para el contexto que está haciendo getActivity.getApplicationContext si está fragmentado, entonces puedo entenderlo, pero si está en actividad no creo que deba llamar a getActivity
Sahil Manchanda
En mi caso hice eso para Fragment. El código se usa dentro de onCreate
Sapphire91140
3

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

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

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
     }
   }
Ishwor Khanal
fuente
2

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
        }
Mayank Sharma
fuente
0

Ú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": {}
    }
]
Tom
fuente