I need to figure out how to get or make a build number for my Android application. I need the build number to display in the UI.
Do I have to do something with AndroidManifest.xml
?
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"
}
com.android.tools.build:gradle:1.3.0
build.config = true
inside of buildfeatures
Commented
Aug 14, 2023 at 21:39
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:
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();
android:versionCode
and android:versionName
can be found here: developer.android.com/tools/publishing/…
this.getPackageName()
represents the 0
you just spit there has no clue about the meaning
Commented
Aug 2, 2018 at 2:41
BuildConfig.VERSION_NAME
Yep, it's that easy now.
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.
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.
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.
versionName "1.2"
, and BuildConfig.VERSION_NAME
return empty
. API > 21
versionCode
and versionName
, respectively. Only because some tools like Code Push attempt to get your version number by parsing your build.gradle
file and they can't full a dynamic value.
Commented
Mar 16, 2018 at 15:56
import com.package.name.BuildConfig;
or directly references it in code, even in a project lib ;)
Commented
Jun 1, 2021 at 12:56
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);
Throws PackageManager.NameNotFoundException if a package with the given name can not be found on the system.
. However, I could not imagine a scenario for that!
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;
val versionCode = BuildConfig.VERSION_CODE
val versionName = BuildConfig.VERSION_NAME
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;
defaultConfig {
applicationId "com.myapp"
minSdkVersion 19
targetSdkVersion 27
versionCode 17
versionName "1.0"
}
As in 2020: As of API 28 (Android 9 (Pie)), "versionCode" is deprecated so we can use "longVersionCode".
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
}
There are two different scenarios in this question that are not properly addressed in any of the answers.
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
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) {
""
}
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
}
);
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";
}
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" />
For Xamarin users, use this code to get version name and code
Version Name:
public string getVersionName(){
return Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0).VersionName;
}
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.
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();
}
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. :)
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 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
int versionCode = BuildConfig.VERSION_CODE;
and to get the version nameString versionName = BuildConfig.VERSION_NAME;