Wie erhalte ich die Build- / Versionsnummer Ihrer Android-Anwendung?

Ich muss herausfinden, wie ich eine Build-Nummer für meine Android-Anwendung erhalte oder erstelle. Ich benötige die Build-Nummer, um sie in der Benutzeroberfläche anzuzeigen.

Muss ich etwas damit anfangen AndroidManifest.xml?

Verwenden:

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

Und Sie können den Versionscode erhalten, indem Sie diesen verwenden

int verCode = pInfo.versionCode;

Wenn Sie das Gradle-Plugin / Android Studio ab Version 0.7.0 verwenden , sind Versionscode und Versionsname statisch in verfügbar BuildConfig. Stellen Sie sicher, dass Sie das Paket Ihrer App importieren und nicht ein anderes BuildConfig:

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

Kein Kontextobjekt erforderlich!

Stellen Sie außerdem sicher, dass Sie sie in Ihrer build.gradleDatei anstelle von angeben AndroidManifest.xml.

defaultConfig {
    versionCode 1
    versionName "1.0"
}

Etwas kürzere Version, wenn Sie nur den Versionsnamen möchten.

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

Sie benötigen zwei Teile: android: versionCode android: versionName

versionCode ist eine Nummer, und jede Version der App, die Sie an den Markt senden, muss eine höhere Nummer als die letzte haben.

Versionsname ist eine Zeichenfolge und kann alles sein, was Sie möchten. Hier definieren Sie Ihre App als "1.0" oder "2.5" oder "2 Alpha EXTREME!" oder Wasauchimmer.

Beispiel:

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

Verwenden von Gradle und BuildConfig

Abrufen des VERSION_NAME von BuildConfig

BuildConfig.VERSION_NAME

Ja, so einfach ist das jetzt.

Gibt es eine leere Zeichenfolge für VERSION_NAME zurück?

Wenn Sie eine leere Zeichenfolge für erhalten, BuildConfig.VERSION_NAMElesen Sie weiter.

Ich habe immer wieder eine leere Zeichenfolge erhalten, BuildConfig.VERSION_NAMEweil ich die versionNamein meiner Grade-Build-Datei nicht festgelegt habe (ich bin von ANT zu Gradle migriert). Hier finden Sie Anweisungen, um sicherzustellen, dass Sie Ihre VERSION_NAMEVia Gradle einstellen .

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

}

Hinweis: Dies ist von dem meisterhaften Jake Wharton .

Entfernen versionNameund versionCodeausAndroidManifest.xml

Und da Sie das versionNameund versionCodein der build.gradleDatei jetzt festgelegt haben, können Sie sie auch aus Ihrer AndroidManifest.xmlDatei entfernen , wenn sie vorhanden sind.

Hier ist eine saubere Lösung , basierend auf der Lösung von Scottyab (bearbeitet von Xavi). Es zeigt, wie Sie den Kontext zuerst abrufen, wenn er nicht von Ihrer Methode bereitgestellt wird. Darüber hinaus werden mehrere Zeilen verwendet, anstatt mehrere Methoden pro Zeile aufzurufen. Dies erleichtert das Debuggen Ihrer Anwendung.

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

myVersionNameNachdem Sie den Versionsnamen in der Zeichenfolge erhalten haben, können Sie ihn auf eine Textansicht oder eine beliebige Textansicht festlegen.

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

Um die App-Version oder den Build-Code zu erhalten, mit dem die apk anhand ihres Versionscodes identifiziert wird. Der Versionscode wird verwendet, um die tatsächliche Build-Konfiguration zum Zeitpunkt der Aktualisierung, Veröffentlichung usw. zu ermitteln.

int versionCode = BuildConfig.VERSION_CODE;

Der Versionsname wird verwendet, um die Benutzer oder Entwickler der Entwicklungssequenz anzuzeigen. Sie können beliebig viele Versionsnamen hinzufügen

String versionName = BuildConfig.VERSION_NAME;

Verwenden Sie die BuildConfig-Klasse

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

Wenn Sie PhoneGap verwenden, erstellen Sie ein benutzerdefiniertes PhoneGap-Plugin:

Erstellen Sie eine neue Klasse im Paket Ihrer App:

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

Fügen Sie in der Datei plugins.xml die folgende Zeile hinzu:

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

Fügen Sie in Ihrem deviceready-Ereignis den folgenden Code hinzu:

var PackageManagerPlugin = function() {

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

Anschließend können Sie das Attribut versionName wie folgt abrufen:

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

Abgeleitet von hier und hier .

Kotlin Einzeiler

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

Stellen Sie sicher, dass Sie BuildConfigin Ihre Klasse importieren

Verwenden Sie für Xamarin-Benutzer diesen Code, um den Versionsnamen und den Code abzurufen

1) Versionsname:

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

2) Versionscode:

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

Wenn Sie es für XML verwenden möchten, fügen Sie die folgende Zeile in Ihre Gradle-Datei ein:

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

Und dann benutze es wie folgt auf deiner XML:

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

Nein, Sie müssen mit AndroidManifest.xml nichts tun

Grundsätzlich der Versionsname und der Versionscode Ihrer App in der Gradle- Datei auf App-Ebene unter dem Tag defaultConfig :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

Hinweis: Wenn Sie eine App im Playstore hochladen möchten, können Sie einen beliebigen Namen als Versionsnamen angeben. Der Versionscode muss sich jedoch vom aktuellen Versionscode unterscheiden, wenn sich diese App bereits im Play Store befindet.

Verwenden Sie einfach das folgende Codefragment, um den Versionscode und den Versionsnamen von einer beliebigen Stelle in Ihrer App abzurufen:

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

Für Api 28 ist der PackageInfo.versionCode veraltet. Verwenden Sie daher den folgenden Code:

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

Mach es immer mit try catchBlock:

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

Hier ist die Methode zum Abrufen des Versionscodes:

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

Ich habe dies mithilfe der Voreinstellungsklasse gelöst.

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

Es gibt einige Möglichkeiten zu bekommen versionCodeund versionNameprogrammatisch.

1. Version abrufen von PackageManager. Dies ist in den meisten Fällen der beste Weg.

try {
    String versionName = packageManager.getPackageInfo(packageName, 0).versionName;
    int versionCode = packageManager.getPackageInfo(packageName, 0).versionCode;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

2. Holen Sie es von generiert BuildConfig.java. Beachten Sie jedoch, dass beim Zugriff auf diese Werte in der Bibliothek die Bibliotheksversion und nicht die App-Version zurückgegeben wird, die diese Bibliothek verwendet. Also nur in Nicht-Bibliotheksprojekten verwenden!

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

Es gibt einige Details, außer der Verwendung der zweiten Methode im Bibliotheksprojekt. Im neuen Android Gradle Plugin (3.0.0+) wurden einige Funktionen entfernt . Im Moment also, dh die Einstellung einer anderen Version für verschiedene Geschmacksrichtungen funktioniert nicht richtig.

Falscher Weg:

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
}

Der obige Code setzt die Werte korrekt ein BuildConfig, aber von PackageManagererhalten Sie 0und nullwenn Sie die Version nicht in der defaultKonfiguration festgelegt haben. Ihre App verfügt also über einen 0Versionscode auf dem Gerät.

Es gibt eine Problemumgehung - stellen Sie die Version für die Ausgabedatei apkmanuell ein:

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

Dieser Code wurde oben in Teilen erwähnt, aber hier ist wieder alles enthalten. Sie benötigen einen Try / Catch-Block, da er möglicherweise eine "NameNotFoundException" auslöst.

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

Ich hoffe, dies vereinfacht die Dinge für jemanden auf der Straße. :) :)

Jemand, der keine BuildConfig-Informationen für die Benutzeroberfläche der Anwendung benötigt, möchte diese Informationen jedoch zum Festlegen einer CI-Jobkonfiguration oder anderer verwenden, wie ich.

Es gibt eine automatisch generierte Datei, BuildConfig.java, unter Ihrem Projektverzeichnis, solange Sie Ihr Projekt erfolgreich erstellen.

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

Teilen Sie die benötigten Informationen nach Python-Skript oder anderen Tools auf. Hier ist ein Beispiel:

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)

Bitte entschuldigen Sie meine eingeschränkten Englischkenntnisse, hoffe aber, dass dies hilft.

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

    }

  }
}

Probier diese:

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

Zuerst:

import android.content.pm.PackageManager.NameNotFoundException;

und dann benutze dies:

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

Beispiel für die Verwendung innerhalb von Fragmenten.

        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

Kotlin Beispiel:

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

Danke nicht :-)

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

Da ich nur den Versionscode erhalten und prüfen musste, ob die App aktualisiert wurde oder nicht, musste ich, wenn ja, den Playstore starten, um einen zu aktualisieren. Ich habe es so gemacht.

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

}

Dann habe ich den Versionscode mit gemeinsamen Einstellungen gespeichert, indem ich eine util-Klasse erstellt habe.

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

Wie im Jahr 2020: API 28 "versionCode" ist veraltet, sodass wir "longVersionCode" verwenden können.

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

Nützlich für Build-Systeme: Es gibt eine mit Ihrer apk generierte Datei namens, output.jsondie ein Array von Informationen für jede generierte APK enthält, einschließlich versionName und versionCode.

z.B

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