Comment obtenir le numéro de build / version de votre application Android?


J'ai besoin de comprendre comment obtenir ou faire un numéro de build pour mon application Android. J'ai besoin du numéro de build à afficher dans l'interface utilisateur.

Dois-je faire quelque chose avec AndroidManifest.xml ?



Answers



Utilisation:

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

Et vous pouvez obtenir le code de version en utilisant cette

int verCode = pInfo.versionCode;



Si vous utilisez le plugin Gradle / Android Studio, à partir de la version 0.7.0 , le code de version et le nom de version sont disponibles de manière statique dans BuildConfig . Assurez-vous d'importer le package de votre application , et non un autre BuildConfig :

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

Aucun objet de contexte nécessaire!

Assurez-vous également de les spécifier dans votre fichier build.gradle au lieu du fichier AndroidManifest.xml .

defaultConfig {
    versionCode 1
    versionName "1.0"
}



Version légèrement plus courte si vous voulez juste le nom de la version.

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



Utilisation de Gradle et BuildConfig

Obtenir la VERSION_NAME à partir de BuildConfig

BuildConfig.VERSION_NAME

Oui, c'est aussi simple maintenant.

Renvoie-t-il une chaîne vide pour VERSION_NAME?

Si vous obtenez une chaîne vide pour BuildConfig.VERSION_NAME lisez la suite.

J'ai continué à obtenir une chaîne vide pour BuildConfig.VERSION_NAME car je ne définissais pas le nom de versionName dans mon fichier de construction Grade (j'ai migré de ANT vers Gradle). Donc, voici les instructions pour vous assurer que vous définissez votre VERSION_NAME via 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}"
  }

}

Note: Ceci est du maître Jake Wharton .

Suppression de AndroidManifest.xml et de AndroidManifest.xml partir de AndroidManifest.xml

Et puisque vous avez défini les paramètres versionName et build.gradle dans le fichier build.gradle maintenant, vous pouvez également les supprimer de votre fichier AndroidManifest.xml , s'ils s'y trouvent.




Vous avez besoin de deux parties: android: versionCode android: versionNom

versionCode est un nombre, et chaque version de l'application que vous soumettez au marché doit avoir un nombre plus élevé que le dernier.

VersionName est une chaîne, et peut être tout ce que vous voulez qu'il soit. C'est ici que vous définissez votre application comme "1.0" ou "2.5" ou "2 Alpha EXTREME!" ou peu importe.

Exemple:

Pour y accéder en code, faites quelque chose comme:

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



Voici une solution propre , basée sur la solution de scottyab (éditée par Xavi). Il montre comment obtenir le contexte en premier, s'il n'est pas fourni par votre méthode. En outre, il utilise plusieurs lignes au lieu d'appeler plusieurs méthodes par ligne. Cela rend plus facile lorsque vous devez déboguer votre application.

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

Maintenant que vous avez reçu le nom de la version dans String myVersionName , vous pouvez le définir comme TextView ou comme vous voulez.

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



Si vous utilisez PhoneGap, créez un plugin PhoneGap personnalisé:

Créez une nouvelle classe dans le package de votre application:

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

Dans le fichier plugins.xml, ajoutez la ligne suivante:

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

Dans votre événement deviceready , ajoutez le code suivant:

var PackageManagerPlugin = function() {

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

Ensuite, vous pouvez obtenir l'attribut versionName en faisant:

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

Dérivé d' ici et ici .




Un moyen très simple est:

private String appVersion = BuildConfig.VERSION_NAME;



Toujours le faire avec 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());
}



Voici la méthode pour obtenir le code de version:

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



J'ai résolu cela en utilisant la classe de préférence.

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



Pour les utilisateurs de xamarin, utilisez ce code pour obtenir le nom et le code de la version

1) Nom de la version:

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

2) Code de version:

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



Si vous voulez l'utiliser sur xml, ajoutez la ligne ci-dessous sur votre fichier gradle:

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

Et puis utilisez-le sur votre xml comme ceci:

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



Quelqu'un qui n'a pas besoin d'informations BuildConfig pour l'interface utilisateur de l'application souhaite toutefois utiliser ces informations pour définir une configuration de travail CI ou d'autres, comme moi.

Il existe un fichier généré automatiquement, BuildConfig.java, dans votre répertoire de projet, à condition que vous ayez réussi votre projet.

{ESPACE DE TRAVAIL} / build / generated / source / buildConfig / {debug | version} / {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";
}

Diviser les informations dont vous avez besoin par script Python ou d'autres outils. Voici un exemple:

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)

S'il vous plaît excusez mes capacités limitées en anglais, mais j'espère que cela vous aidera.




Ce code a été mentionné ci-dessus en morceaux mais ici il est à nouveau tout inclus. Vous avez besoin d'un bloc try / catch car il peut lancer une "NameNotFoundException".

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

J'espère que cela simplifiera les choses pour quelqu'un d'autre. :)




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

    }

  }
}



Premier:

import android.content.pm.PackageManager.NameNotFoundException;

puis utilisez ceci:

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



essaye celui-là:

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



Exemple d'utilisation de fragment à l'intérieur.

        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



Il existe plusieurs façons d'obtenir par programme versionName et versionName .

  1. Obtenez la version de PackageManager . C'est le meilleur moyen pour la plupart des cas.
try {
    String versionName = packageManager.getPackageInfo(packageName, 0).versionName;
    int versionCode = packageManager.getPackageInfo(packageName, 0).versionCode;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}
  1. Obtenez-le à partir de BuildConfig.java généré. Mais remarquez, que si vous accédez à ces valeurs dans la bibliothèque, il retournera la version de la bibliothèque, pas celle des applications, qui utilise cette bibliothèque. Donc, utilisez uniquement dans des projets non-bibliothèque!
String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;

Il y a quelques détails, à l'exception de l'utilisation de la deuxième manière dans le projet de bibliothèque. Dans le nouveau plugin android gradle (3.0.0+), certaines fonctionnalités ont été supprimées . Donc, pour l'instant, c'est-à-dire que la définition d'une version différente pour différentes saveurs ne fonctionne pas correctement.

Manière incorrecte:

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
}

Le code ci-dessus définira correctement les valeurs dans BuildConfig , mais à partir de BuildConfig , vous recevrez 0 et null si vous n'avez pas défini la version dans la configuration default . Donc, votre application aura 0 code de version sur l'appareil.

Il existe une solution de contournement: définissez la version du fichier apk sortie manuellement:

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