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

utiliser:

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 ce

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 la version sont disponibles statiquement dans BuildConfig . assurez-vous d'importer le paquet de votre application , et non 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 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;

il y a deux parties dont vous avez besoin: 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 qu'il soit. C'est là que vous définissez votre application comme "1.0" ou "2.5" ou "2 alpha EXTREME!"ou quoi que ce soit.

exemple:

pour y accéder en code, faire 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();

à l'Aide de Gradle et BuildConfig

Getting the VERSION_NAME from BuildConfig

BuildConfig.VERSION_NAME

Oui, c'est facile maintenant.

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

si vous recevez une chaîne vide pour BuildConfig.VERSION_NAME alors lire sur.

Je n'arrêtais pas de recevoir une chaîne vide pour BuildConfig.VERSION_NAME parce que je ne mettais pas la versionName dans mon fichier Grade (j'ai migré de ANT à Grad). Donc, voici les instructions pour vous assurer que vous paramétrez votre VERSION_NAME via Gradle.

"1519280920 de construire".Grad

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 .

enlevant versionName et versionCode de AndroidManifest.xml

et depuis vous avez défini les versionName et versionCode dans le fichier build.gradle maintenant, vous pouvez également les supprimer de votre fichier AndroidManifest.xml , s'ils sont là.

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é d'obtenir à partir du gestionnaire de paquet

Voici une solution propre , basée sur la solution de scottyab (éditée par Xavi). Il montre comment obtenir le contexte d'abord, si elle n'est pas fournie par votre méthode. De plus, il utilise plusieurs lignes au lieu d'appeler plusieurs méthodes par ligne. Cela facilite le débogage de 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 de caractères myVersionName , vous pouvez le définir à une version TextView ou ce que vous voulez..

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

si vous utilisez PhoneGap, alors créez un plugin PhoneGap personnalisé:

créez une nouvelle classe dans le paquet 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 les plugins.xml, ajouter la ligne suivante:

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

dans votre événement deviceready , ajouter 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());
});

alors, 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é de ici et ici .

une façon très simple est:

private String appVersion = BuildConfig.VERSION_NAME;

toujours le faire avec try catch bloc:

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

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

1) Nom De La Version:

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

2) La Version De Code:

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

j'ai résolu ceci 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);
        }
    }
}

si vous voulez l'utiliser sur xml, ajoutez la ligne suivante dans votre fichier gradle:

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

et ensuite l'utiliser sur votre xml comme ceci:

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

Use Classe BuildConfig

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

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

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

il y a un fichier généré automatiquement, BuildConfig.java, sous votre répertoire de projet aussi longtemps que vous construisez votre projet avec succès.

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

Split informations dont vous avez besoin par Python script 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 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 essayer/attraper parce qu'il peut jeter un "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 en bas de la route. :)

il y a plusieurs façons de programmer versionCode et versionName .

1. Obtenir la version de PackageManager . C'est la meilleure façon 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. Obtenir à partir de produits BuildConfig.java . Mais notez que si vous accédez à ces valeurs dans la bibliothèque, il retournera la version de la Bibliothèque, pas apps one, qui utilise cette bibliothèque. Ainsi utiliser seulement dans les projets non-bibliothèque!

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

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

chemin Incorrect:

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 de BuildConfig , mais à partir de PackageManager vous recevrez 0 et null si vous n'avez pas défini la version dans la configuration default . Donc votre application aura le code de version 0 sur le périphérique.

il y a une version de contournement pour 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
    }
}

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

    }

  }
}

d'Abord:

import android.content.pm.PackageManager.NameNotFoundException;

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

essayez celui-ci:

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

Dans Activité fichier

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

j'espère que cela vous aidera...!

exemple d'utilisation d'un Fragment 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

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