Comment obtenir le numéro de version / version de votre application Android?
Je dois trouver 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 cette
int verCode = pInfo.versionCode;
Si vous utilisez le plugin Gradle/Android Studio, à partir de la version 0.7. , 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 pas 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 à la place 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;
Vous avez besoin de deux parties: Android: versionCode Android: versionName
versionCode est un numéro et chaque version de l'application que vous soumettez au marché doit avoir un numéro plus élevé que le dernier.
VersionName est une chaîne et peut être ce que vous voulez. C'est ici que vous définissez votre application comme "1.0", "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();
Utiliser Gradle et BuildConfig
Obtention de VERSION_NAME à partir de BuildConfig
BuildConfig.VERSION_NAME
Oui, c'est aussi simple que ça.
Renvoie-t-il une chaîne vide pour VERSION_NAME?
Si vous obtenez une chaîne vide pour BuildConfig.VERSION_NAME, continuez votre lecture.
Je continuais à avoir une chaîne vide pour BuildConfig.VERSION_NAME parce que je n'étais pas en train de définir le versionName dans mon fichier de construction Grade (j'ai migré d'ANT vers Gradle). Donc, voici les instructions pour vous assurer de régler 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: Cela vient du maître Jake Wharton .
Suppression de versionName et versionCode de AndroidManifest.xml
Et puisque vous avez défini les paramètres versionName et versionCode dans le fichier build.gradle, vous pouvez également les supprimer de votre fichier AndroidManifest.xml, s'ils sont présents.
BuildConfig.VERSION_NAME //version name from your build file
BuildConfig.VERSION_CODE //version code from your build file
Je ne vois pas la nécessité de l'obtenir du gestionnaire de paquets
Voici un solution propre, basé 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 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 un TextView ou ce que vous voulez.
// set version name to a TextView
TextView tvVersionName = (TextView) findViewById(R.id.tv_versionName);
tvVersionName.setText(myVersionName);
Utilisez la classe BuildConfig
String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;
build.gradle (app)
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 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
}
);
Un moyen très simple est:
private String appVersion = BuildConfig.VERSION_NAME;
Voici le moyen simple d'obtenir nom de version et code de version
String version_name=BuildConfig.VERSION_NAME;
int version_code=BuildConfig.VERSION_CODE;
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 le XML, ajoutez la ligne ci-dessous sur votre fichier Gradle:
applicationVariants.all { variant ->
variant.resValue "string", "versionName", variant.versionName
}
Et utilisez-le ensuite sur votre XML comme ceci:
<TextView
Android:gravity="center_horizontal"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:text="@string/versionName" />
Pour obtenir le code de construction utilisé pour identifier l'apk par son code de version. Le code de version est utilisé pour déterminer la configuration de construction réelle au moment de la mise à niveau, de la publication, de la base de données, etc.
int versionCode = BuildConfig.VERSION_CODE;
Le nom de version est utilisé pour lier les utilisateurs aux développeurs de la séquence de développement. Vous pouvez ajouter n'importe quel type de nom de version à votre guise.
String versionName = BuildConfig.VERSION_NAME;
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;
}
Toujours le faire avec le bloc 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());
}
J'ai résoudre ce problème 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 Api 28, PackageInfo.versionCode est obsolète, utilisez 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";
}
Il y a plusieurs façons d'obtenir versionCode et versionName par programmation.
- Obtenir 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();
}
- Obtenez-le à partir de
BuildConfig.Javagénéré. Mais notez que si vous accédez à ces valeurs dans la bibliothèque, elle renverra la version de la bibliothèque, et non celle des applications, qui utilise cette bibliothèque. Donc à utiliser uniquement dans des projets autres que des bibliothèques!
String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;
Il y a quelques détails, excepté l'utilisation de la deuxième manière dans le projet de bibliothèque. Dans le nouveau Android gradle plugin (3.0.0+), quelques fonctionnalités supprimées . Donc, pour l’instant, c’est-à-dire que vous définissez une version différente pour différentes versions ne fonctionnant 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 PackageManager, vous recevrez 0 et null si vous n'avez pas défini de version dans default configuration. Ainsi, votre application aura le code de version 0 sur l'appareil.
Il existe une solution de contournement - définissez la version de la sortie apk fichier 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
}
}
Non, vous n'avez rien à faire avec AndroidManifest.xml
En gros, le nom et le code de version de votre application à l'intérieur du gradateur de niveau de l'application fichier, sous defaultConfig tag:
defaultConfig {
versionCode 1
versionName "1.0"
}
Remarque: lorsque vous souhaitez télécharger une application dans PlayStore, vous pouvez donner un nom quelconque à celui de la version, mais le code de version doit être différent du code de la version actuelle si cette application est déjà dans Play Store.
Utilisez simplement l'extrait de code suivant pour obtenir code de version & nom de version à partir 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();
}
Ce code a été mentionné ci-dessus en morceaux, mais ici, il est à nouveau inclus. Vous avez besoin d'un bloc try/catch car il peut générer 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 au bout du chemin. :)
Une personne 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 de CI ou autre, comme moi.
Il existe un fichier généré automatiquement, BuildConfig.Java, dans le répertoire de votre projet, à condition que vous construisiez votre projet avec succès.
{WORKSPACE}/build/generate/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 le 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)
Excusez mes compétences limitées en anglais, mais espérons que cela vous aidera.
essaye celui-là:
try
{
device_version = getPackageManager().getPackageInfo("com.google.Android.gms", 0).versionName;
}
catch (PackageManager.NameNotFoundException e)
{
e.printStackTrace();
}
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) {
}
}
}
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;
}
}
Première:
import Android.content.pm.PackageManager.NameNotFoundException;
et ensuite utiliser ceci:
PackageInfo pInfo = null;
try {
pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
} catch (NameNotFoundException e) {
e.printStackTrace();
}
String versionName = pInfo.versionName;
Exemple d'utilisation à l'intérieur d'un 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
Comme je devais obtenir uniquement le code de version et vérifier si l'application est mise à jour ou non, si oui, je devais lancer le magasin de jeu pour en obtenir un mis à jour. 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
}
}
PackageInfo pinfo = null;
try {
pinfo = getPackageManager().getPackageInfo(getPackageName(), 0);
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
int versionNumber = pinfo.versionCode;
String versionName = pinfo.versionName;
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();
}
Exemple 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 remercie pas :-)
Utile pour les systèmes de construction: il existe un fichier généré avec votre apk appelé output.json qui contient un tableau d'informations pour chaque APK généré, y compris versionName et versionCode.
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": {}
}
]
Comme en 2019: API 28 "versionCode" est obsolète afin que nous puissions utiliser "longVersionCode"
Exemple de code 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
}