How can you get the build/version number of your Android application?

If you're using the Gradle plugin/Android Studio, as of version 0.7.0, version code and version name are available statically in BuildConfig. Make sure you import your app's package, and not another BuildConfig:

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

No Context object needed!

Also make sure to specify them in your build.gradle file instead of the AndroidManifest.xml.

defaultConfig { versionCode 1 versionName "1.0" } 

Use:

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

And you can get the version code by using this

int verCode = pInfo.versionCode; 

Slightly shorter version if you just want the version name.

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

There are two parts you need:

• android:versionCode
• android:versionName

versionCode is a number, and every version of the app you submit to the market needs to have a higher number than the last.

VersionName is a string and can be anything you want it to be. This is where you define your app as "1.0" or "2.5" or "2 Alpha EXTREME!" or whatever.

Example:

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

Using Gradle and BuildConfig

Getting the VERSION_NAME from BuildConfig

BuildConfig.VERSION_NAME 

Yep, it's that easy now.

Is it returning an empty string for VERSION_NAME?

If you're getting an empty string for BuildConfig.VERSION_NAME then read on.

I kept getting an empty string for BuildConfig.VERSION_NAME, because I wasn't setting the versionName in my Grade build file (I migrated from Ant to Gradle). So, here are instructions for ensuring you're setting your VERSION_NAME via Gradle.

File 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: This is from the masterful Jake Wharton.

Removing versionName and versionCode from AndroidManifest.xml

And since you've set the versionName and versionCode in the build.gradle file now, you can also remove them from your AndroidManifest.xml file, if they are there.

Here is a clean solution, based on the solution of scottyab (edited by Xavi). It shows how to get the context first, if it's not provided by your method. Furthermore, it uses multiple lines instead of calling multiple methods per line. This makes it easier when you have to debug your 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(); } 

Now that you received the version name in the String myVersionName, you can set it to a TextView or whatever you like..

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

Use the following to get the app version or build code which is used to identify the APK file by its version code. The version code is used to detect the actual build configuration at the time of update, publishing, etc.

int versionCode = BuildConfig.VERSION_CODE; 

The version name is used to show the users or the developers of the development sequence. You can add any kind of version name as you want.

String versionName = BuildConfig.VERSION_NAME; 

Kotlin one-liners

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

Java one-liners

String versionCode = String.valueOf(BuildConfig.VERSION_CODE); String versionName = String.valueOf(BuildConfig.VERSION_NAME); 

Make sure to import BuildConfig into your class.

Use the BuildConfig class:

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

File build.gradle (app)

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

There are two different scenarios in this question that are not properly addressed in any of the answers.

Scenario 1: You are not using modules

If you are not making use of modules, you can access your BuildConfig file and immeditally get your version code with:

val versionCode = BuildConfig.VERSION_CODE 

This is valid because this is your app level BuildConfig file and therefor it will contain the reference to your application version code

Scenario 2: Your app has many modules and you pretend to access the application version code from a lower module in your module hierarchy

It is normal for you to have many modules with a given hierarchy such as app -> data -> domain -> ui, etc. In this case, if you access the BuildConfig file from the "ui" module it will not give you a reference to the app version code but to the version code of that module.

In order to get the application version code you can use the following given code:

First an extension function to get the PackageInfo

@Suppress("DEPRECATION") fun Context.getPackageInfo(): PackageInfo { return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { packageManager.getPackageInfo(packageName, PackageManager.PackageInfoFlags.of(0)) } else { packageManager.getPackageInfo(packageName, 0) } } 

Extension function to get the version code

fun Context.getVersionCode(): Int = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { getPackageInfo().longVersionCode.toInt() } else { getPackageInfo().versionCode } 

The approach for version name is similar:

fun Context.getVersionName(): String = try { getPackageInfo().versionName } catch (e: PackageManager.NameNotFoundException) { "" } 

As in 2020: As of API 28 (Android 9 (Pie)), "versionCode" is deprecated so we can use "longVersionCode".

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

If you're using PhoneGap, then create a custom PhoneGap plugin:

Create a new class in your app's package:

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

In the plugins.xml, add the following line:

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

In your deviceready event, add the following code:

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

Then, you can get the versionName attribute by doing:

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

Derived from here and here.

No, you don't need to do anything with AndroidManifest.xml

Basically, your app's version name and version code are inside the app level Gradle file, under defaultConfig tag:

defaultConfig { versionCode 1 versionName "1.0" } 

Note: When you wish to upload an app to the play store, it can give any name as the version name, but the version code has to be different than the current version code if this app is already in the play store.

Simply use the following code snippet to get the version code & version name from anywhere in your app:

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

For API 28 (Android 9 (Pie)), the PackageInfo.versionCode is deprecated, so use this code below:

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

Version name: BuildConfig.VERSION_NAME
Version code: BuildConfig.VERSION_CODE

If you want to use it on XML content then add the below line in your Gradle file:

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

And then use it on your XML content like this:

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

May 2024
To retrieve the VERSION_CODE, simply you can use the BuildConfig class like the following code:

val versionCode = BuildConfig.VERSION_CODE 

Just remember, The BuildConfig class is automatically generated for all Android modules by default (Gradle Plugin 8.0.0+), but If you are using an older version of the plugin or using custom fields in your BuildConfig class, you will need to explicitly enable BuildConfig in your module's build.gradle file. (like as compose projects)

To fix the issue of importing BuildConfig in your Jetpack Compose project, follow these steps:

1. Add the below code in the build.gradle(app module) within android block.

 android { //.... buildFeatures { //... buildConfig = true // add this //... } //.... } 

2. Sync your project with the Gradle files(the elephant button with a down arrow). This step ensures that the build system applies the changes and generates the required code.

3. (If the problem still persists) Run "invalidate cache and restart" from the "File" menu.

4. Finally, Run "Rebuild Project" from the "Build" menu.

⭕ Don't forget to import import com.xxx.zzz.BuildConfig (Sometimes IDE doesn't do it for you)

For Xamarin users, use this code to get version name and code

1. Version Name:

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

2. Version code:

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

Always do it with a try catch block:

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

Here is the method for getting the version code:

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

I have solved this by using the Preference class.

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

There are some ways to get versionCode and versionName programmatically.

1. Get version from PackageManager. This is the best way for most cases.

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

2. Get it from generated BuildConfig.java. But notice, that if you'll access this values in library it will return library version, not apps one, that uses this library. So use only in non-library projects!

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

There are some details, except of using second way in library project. In new Android Gradle plugin (3.0.0+) some functionalities removed. So, for now, i.e. setting different version for different flavors not working correct.

Incorrect way:

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 } 

Code above will correctly set values in BuildConfig, but from PackageManager you'll receive 0 and null if you didn't set version in default configuration. So your app will have 0 version code on device.

There is a workaround - set version for output apk file manually:

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

This code was mentioned above in pieces, but here it is again all included. You need a try/catch block, because it may throw a "NameNotFoundException".

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

I hope this simplifies things for someone down the road. :)

For someone who doesn’t need the BuildConfig information for application's UI, however wants to use this information for setting a CI job configuration or others, like me:

There is an automatically generated file, BuildConfig.java, under your project directory as long as you build your project successfully.

{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 information you need by a Python script or other tools. Here’s an example:

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) 

First:

import android.content.pm.PackageManager.NameNotFoundException; 

and then use this:

PackageInfo pInfo = null; try { pInfo = getPackageManager().getPackageInfo(getPackageName(), 0); } catch (NameNotFoundException e) { e.printStackTrace(); } String versionName = pInfo.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) { } } } 

Try this one:

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

Kotlin example:

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

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

Example for inside Fragment usage.

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 it useful 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 useful with that