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

J'ai besoin de savoir comment obtenir ou créer 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?

Utilisation:

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

Et vous pouvez obtenir le code de version en utilisant ceci

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 statiquement dans BuildConfig. Assurez-vous d'importer le package de votre application , et pas un autre BuildConfig:

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

Aucun objet contextuel nécessaire!

Assurez-vous également de les spécifier dans votre build.gradlefichier au lieu de 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;

Il vous faut deux parties: android: versionCode android: versionName

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. C'est là que vous définissez votre application comme "1.0" ou "2.5" ou "2 Alpha EXTREME!" ou peu importe.

Exemple:

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

Utilisation de Gradle et BuildConfig

Obtenir la VERSION_NAME de BuildConfig

BuildConfig.VERSION_NAME

Oui, c'est aussi simple que ça maintenant.

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

Si vous obtenez une chaîne vide pour BuildConfig.VERSION_NAMEensuite continuer la lecture.

J'ai continué à obtenir une chaîne vide BuildConfig.VERSION_NAMEparce que je ne définissais pas le versionNamefichier dans mon fichier de génération de notes (j'ai migré d'ANT vers Gradle). Voici donc des instructions pour vous assurer que vous configurez votre VERSION_NAMEvia 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}"
  }

}

Remarque: Ceci est du magistral Jake Wharton .

Suppression versionNameet versionCodedeAndroidManifest.xml

Et puisque vous avez défini le versionNameet versionCodedans le build.gradlefichier maintenant, vous pouvez également les supprimer de votre AndroidManifest.xmlfichier, s'ils existent.

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. De plus, il utilise plusieurs lignes au lieu d'appeler plusieurs méthodes par ligne. Cela vous facilite la tâche 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 la chaîne myVersionName, vous pouvez le définir sur une TextView ou tout ce que vous voulez.

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

Pour obtenir la version de l'application ou le code de construction qui est utilisé pour identifier l'apk par son code de version. Le code de version est utilisé pour détecter la configuration de build réelle au moment de la mise à jour, de la publication, etc.

int versionCode = BuildConfig.VERSION_CODE;

Le nom de la version est utilisé pour afficher les utilisateurs ou les développeurs de la séquence de développement. Vous pouvez ajouter tout type de nom de version comme vous le souhaitez

String versionName = BuildConfig.VERSION_NAME;

Utiliser la classe BuildConfig

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

build.gradle (application)

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

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

Kotlin one-liners

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

Assurez-vous d'importer BuildConfigdans votre classe

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 souhaitez l'utiliser sur xml, ajoutez la ligne ci-dessous sur votre fichier de notes:

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

Non, vous n'avez rien à faire avec AndroidManifest.xml

Fondamentalement, le nom et le code de version de votre application dans le fichier de niveau de l'application , sous la balise defaultConfig :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

Remarque: Lorsque vous souhaitez télécharger une application dans Playstore, vous pouvez donner n'importe quel nom comme nom de version, mais le code de version doit être différent du code de version actuel si cette application est déjà dans Play Store.

Utilisez simplement l'extrait de code suivant pour obtenir le code et le nom de la version de n'importe où dans votre application:

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

pour Api 28, PackageInfo.versionCode est obsolète, utilisez donc ce code ci-dessous:

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

Faites-le toujours avec le try catchbloc:

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

Il existe plusieurs façons d'obtenir versionCodeet par versionNameprogramme.

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

2. Obtenez-le de généré BuildConfig.java. Mais notez que si vous accédez à ces valeurs dans la bibliothèque, il retournera la version de la bibliothèque, et non celle des applications, qui utilise cette bibliothèque. N'utilisez donc que dans des projets non liés à la 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 voie 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.-à-d. Définir 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 PackageManagervous en recevrez 0et nullsi vous n'avez pas défini la version dans la defaultconfiguration. Ainsi, votre application aura un 0code de version sur l'appareil.

Il existe une solution de contournement - définir apkmanuellement la version du fichier de sortie :

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

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 lever une "NameNotFoundException".

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

J'espère que cela simplifie les choses pour quelqu'un sur la route. :)

Quelqu'un qui n'a pas besoin des informations BuildConfig pour l'interface utilisateur de l'application souhaite cependant 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, sous le répertoire de votre projet tant que vous générez votre projet avec succès.

{ESPACE DE TRAVAIL} / build / généré / 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";
}

Divisez les informations dont vous avez besoin par un 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)

Veuillez excuser ma capacité limitée en anglais, mais j'espère que cela vous aidera.

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

    }

  }
}

essaye celui-là:

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

Première:

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

Exemple d'utilisation de Fragments intérieurs.

        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

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

Ne remerciez pas :-)

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

Comme je ne devais obtenir que le code de version et vérifier si l'application est mise à jour ou non, si oui, j'ai dû lancer le Playstore pour en obtenir un. J'ai fait comme ça.

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

}

Ensuite, j'ai enregistré le code de version en utilisant les préférences partagées en créant une classe 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
     }
   }

Comme en 2020: l'API 28 "versionCode" est obsolète pour que nous puissions utiliser "longVersionCode"

Exemple de code dans 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
        }

Utile pour les systèmes de build: un fichier généré avec votre apk appelé output.jsoncontient un tableau d'informations pour chaque APK généré, y compris le nom de version et le code de version.

par exemple

[
    {
        "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": {}
    }
]