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


1289

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?


2
Pas sûr, mais je pense que vous pouvez l'obtenir en analysant le fichier AndroidManifest.xml.
Sunit Kumar Gupta


Pour obtenir le code de version, utilisez int versionCode = BuildConfig.VERSION_CODE;et pour obtenir le nom de la versionString versionName = BuildConfig.VERSION_NAME;
Lukas

Réponses:


2041

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;

52
@Felix vous ne pouvez pas appeler getPackageManager () en dehors du contexte, donc getApplicationContext () (ou le contexte passé) peut être nécessaire.
Sver

2
que faire si vous avez besoin de ce nombre dans une méthode statique où vous ne pouvez pas passer le contexte? mauvais design de ma part?
Gubatron

35
Et n'oubliez pas try... catch..quandgetPackageInfo()
anticafe

4
@Gubatron ma réponse ci-dessous permet de récupérer ces valeurs statiquement.
Sam Dozor

25
Si vous souhaitez uniquement obtenir la version de l'application, il s'agit de deux versions compliquées. Vous devez utiliser BuildConfig.VERSION_**comme suggéré ici .
Timo Bähr

1921

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

178
C'est en fait beaucoup mieux que tout le gestionnaire de contexte et de package, merci.
superjugy

16
En fait, ce sont les meilleures solutions après le lancement d'Android Studio !!! +1 de mon côté
Dhruvil Patel

15
Ce n'est pas très fiable. Le nom de la version apparaît la plupart du temps sous forme de chaîne vide.
Binoy Babu

20
@BinoyBabu, il ne devrait jamais apparaître comme une chaîne vide si vous avez spécifié un versionNamepour votre application dans votre build.gradlefichier.
Sam Dozor

39
Vous devrez importer le package correct pour que cela fonctionne:import com.yourapppackage.android.BuildConfig
Eric B.

438

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

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

81
Excellent. Cela devrait probablement être entouré de try / catch pour NameNotFoundException.
IgorGanapolsky

6
+1 J'ai implémenté votre solution qui fonctionne très bien! Cependant, cette solution doit être entourée par try and catch comme Igor l'a dit ET il est recommandé (par exemple pour le débogage) de placer chaque appel de méthode sur une ligne distincte au lieu d'appeler context.methodName (). SubMethod (). AnotherSubMethod () etc. sur une seule ligne. Par conséquent, j'ai fourni une solution plus propre ci
Michael

1
C'est la bonne solution, merci;) Mais, comme suggéré par @IgorGanapolsky, il doit être entouré de try / catch :)
andrea.rinaldi

2
pour ceux qui utilisent Gradle - il existe une solution plus simple. Voir ma réponse ci-dessous.
Sam Dozor

1
@Erwinus Je suis totalement en désaccord avec l'idée d'utiliser une exception générique pour attraper des trucs comme ça. Des exceptions plus précises montrent que le développeur comprend les erreurs possibles.
IgorGanapolsky

174

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

6
La description officielle d'Android android:versionCodeet android:versionNamepeut être trouvée ici: developer.android.com/tools/publishing/…
Jeffro

2
ce dans ce cas est l' activité de contexte .ie, service .etc
peterchaula

3
lorsque vous collez un exemple de code est utile pour expliquer la signification des paramètres .... bien que tout le monde puisse comprendre ce this.getPackageName()que 0vous venez de cracher, il n'y a aucune idée de la signification
Rafael Lima

Android Studio affirme que la version est dépréciée
Roman Gherta

1
@RomanGherta C'est à partir de l'API 28. Si vous écrivez du code en utilisant quelque chose de moins (ou il y a 8 ans lorsque cette réponse a été écrite), vous devriez toujours être prêt à partir. Une autre réponse ici a la méthode mise à jour.
Merkidemis

146

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.


5
Cela fonctionne très bien tant que vous accédez à BuildConfig à partir du projet d'application, et non à une bibliothèque utilisée dans le projet d'application. Sinon, vous obtiendrez le BuildConfig pour le projet de bibliothèque, pas l'application.
John Cummings, du

@JohnCummings Intéressant ... n'y a pas pensé.
Joshua Pinter

Ne fonctionne pas du tout versionName "1.2", et BuildConfig.VERSION_NAMErevenez empty. API> 21
Sojtin

En guise de suivi, nous avons en fait cessé d'utiliser cette méthode au profit d'un simple entier statique et d'une chaîne statique pour le versionCodeet versionName, respectivement. Uniquement parce que certains outils comme Code Push tentent d'obtenir votre numéro de version en analysant votre build.gradlefichier et ne peuvent pas remplir une valeur dynamique.
Joshua Pinter

@JoshuaPinter PackageManager est vraiment l'option la plus sûre. Si vous utilisez des remplacements de code de version pour les scissions, la constante BuildConfig conserve toujours la valeur d'origine (quoique aromatisée).
Eugen Pechanec

54

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

Pensez-vous que NNFE peut être vraiment jeté? Il serait étrange de ne pas trouver d'application en cours d'exécution dans le gestionnaire de paquets :)
TWiStErRob

Je suis avec vous que cela pourrait être bizarre, mais c'est l'exception par défaut de cette méthode - voir API : ça dit Throws PackageManager.NameNotFoundException if a package with the given name can not be found on the system.. Cependant, je ne pouvais pas imaginer un scénario pour ça!
Michael

38

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;

34

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

23

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 .


9
La question ne concernait pas PhoneGap. Votre réponse pourrait simplement confondre les gens.
likebobby

8
@BobbyJ Nulle part dans la question, le titre ou les balises ne spécifie que la question concernait une application native. C'est ce qui est apparu sur Google lorsque je cherchais la réponse, et cela m'aurait fait gagner plusieurs heures.
Sean Hall

Merci Hall72215. Je serai heureux de cela ... s'il n'y a vraiment pas d'autre moyen d'obtenir votre propre numéro de version? Je préfère éviter un plugin si possible!
Magnus Smith

@MagnusSmith Pas à moins que PhoneGap / Cordova l'ait ajouté à leurs fonctions intégrées.
Sean Hall

Dans cet exemple, vous pouvez voir à quel point il est stupide d'utiliser des solutions tierces pour créer des applications. Lorsque vous l'avez écrit vous-même à partir de zéro, ce n'était que quelques lignes à coder.
Codebeat

19

Kotlin one-liners

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

Assurez-vous d'importer BuildConfigdans votre classe


13

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

12

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

J'obtiens dans mon xml l'erreur: Impossible de résoudre le symbole '@ string / versionName'
RJB

12

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

1
versionCode a été déconseillé dans l'API 28. Comme indiqué dans les documents, utilisez plutôt longVersionCode; developer.android.com/reference/android/content/pm/…
Dan Abnormal

11

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

9

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

9

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

3
Meilleure méthode - BuildConfig.VERSION_CODE
Jaydev

8

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

8

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

6

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


5

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.


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

    }

  }
}

Salut, @donmj. Si vous utilisez un root officiel pour un appareil Android. Je pense que tu en auras besoin. Telle est mon approche.
Durul Dalkanat

Merci pour l'aide @Durul Dalkanat :).
donmj

4

essaye celui-là:

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

3

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;

1
aucun corps n'a le temps pour ça.
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;
        }
    }

3

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

Vous devriez regarder d'autres réponses avant de poster votre réponse. par exemple pour le contexte que vous faites getActivity.getApplicationContext si vous êtes en fragment alors je peux comprendre mais si vous êtes en activité je ne pense pas que vous auriez besoin d'appeler getActivity
Sahil Manchanda

Dans mon cas, j'ai fait ça pour Fragment. Le code est utilisé à l'intérieur de onCreate
Sapphire91140

3

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


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

2

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

2

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
        }

0

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": {}
    }
]
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.