How to get minimum sdk version(minSdkVersion) at runtime? - android

I wanted to get the minSdkVersion used to build the app at runtime. I tried with the below code.
getPackageManager().getPackageInfo(context.getPackageName(), 0).applicationInfo.targetSdkVersion
In the documentation the targetSdkVersion is mentioned with the comment The minimum SDK version this application targets.. But it is providing the current version where the application is running.
Is there any predefined way is available to get the minSdkVersion? (or)
Is there any hack is possible to get the minSdkVersion?


If you want you can also declare it in your gradle like:
defaultConfig {
minSdkVersion 16
targetSdkVersion 23
versionCode 5
versionName "some name"
applicationId "com.myapp"
buildConfigField "int", "MIN_SDK_VERSION", "$minSdkVersion.apiLevel"
}
then in your code you just need to get it like:
BuildConf.MIN_SDK_VERSION


targetSdkVersion : The minimum SDK version this application targets
int targetSdkVersion= 0;
IPackageManager manager = AppGlobals.getPackageManager();
try {
ApplicationInfo applicationInfo = manager.getApplicationInfo(appName, 0);
if (applicationInfo != null) {
targetSdkVersion= applicationInfo.targetSdkVersion;
}
}
You can get more info https://developer.android.com/reference/android/content/pm/ApplicationInfo.html#targetSdkVersion


#PedroAGSantos's answer is not 100% correct, we need to use apiLevel property of minSdkVersion and we don't need extra quotes. here is the corrected version:
defaultConfig {
minSdkVersion 16
targetSdkVersion 23
versionCode 5
versionName "some name"
applicationId "com.myapp"
buildConfigField "int", "MIN_SDK_VERSION", "$minSdkVersion.apiLevel"
}


This is how you can get minimum SDK and target SDK version during runtime
PackageManager packageM = getPackageManager();
String packageName = getPackageName();
int targetVersion = 0, minVersion = 0;
PackageInfo info = null;
try {
info = packageM.getPackageInfo(packageName, 0);
ApplicationInfo applicationInfo = info.applicationInfo;
targetVersion = applicationInfo.targetSdkVersion;
minVersion = applicationInfo.minSdkVersion;
......
}
catch (Exception ex)
{
}
Shorted way:
int minimumSDK = getApplicationContext().getApplicationInfo().minSdkVersion;
int targSDK = getApplicationContext().getApplicationInfo().targetSdkVersion;

Related

Use Gradle Play Publisher's version name override in Java

Gradle Play publisher lets you override the version name before publishing to the play store.
play {
// ...
resolutionStrategy = "auto"
outputProcessor { // this: ApkVariantOutput
versionNameOverride = "$versionNameOverride.$versionCode"
}
}
Is it possible to use the value of versionNameOverride in Java Code? We display the version name in the about page of the app using the versionName attribute. GPP updates the versionNameOverride value so the play store listing shows the correct version number but the app's about page keeps showing a different version number that's based on versionName.

Using the versionNameOverride could be done like this:
outputProcessor { output ->
output.versionNameOverride = output.versionNameOverride + "." + output.versionCode
def versionPropertyFile = file "version.properties"
def versionProperties = new Properties()
versionProperties.setProperty('versionCode', "$output.versionCode")
versionProperties.setProperty('versionName', output.versionNameOverride)
versionPropertyFile.withWriter { versionProperties.store(it, "Generated by the outputProcessor for the play plugin during publishing.") }
}
But if you want to show the versionName in your app it would be easier to use
try {
PackageInfo pInfo =
context.getPackageManager().getPackageInfo(getPackageName(), 0);
String version = pInfo.versionName;
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
The reason why your app did show the wrong values might be that your app was using BuildConfig. But the versionCode and versionName there do not reflect what has been set through versionNameOverride, but those values from your build gradle.

How to know an app's target sdk version

I'm doing some android analysis and need to find all the android app that have targetSdkversion over 23, right now I'm reverse engineering all the apk packages to see this...Wondering if there's more easy way to get this information given an app name?
Thanks :)

you can do that by this code:
int sdkVersion = 0;
IPackageManager packageManager = AppGlobals.getPackageManager();
try {
ApplicationInfo appInfo = packageManager.getApplicationInfo(yourAppName, 0);
if (applInfo != null) {
sdkVersion = applicationInfo.targetSdkVersion;
}
}

Is it possible to get other application version?

Is it possible to findout version of another application?
I can find if it is installed
android.content.pm.PackageManager mPm = getPackageManager(); // 1
PackageInfo info = mPm.getPackageInfo(pName, 0); // 2,3
Boolean installed = info != null;
But i miss relative field in packageinfo or applicationinfo

versionCode and versionName are each fields in PackageInfo.

Obtaining version of youtube android app

I guys,
is there a method to find what version of the youtube player installed in my phone thru java code?
Thanks.

Try using:
String versionName = context.getPackageManager().getPackageInfo("youtube's package name as String", 0 ).versionName;
int versionCode = context.getPackageManager().getPackageInfo("youtube's package name as String", 0 ).versionCode;
Make sure to wrap this in a try-catch block for the NameNotFoundException incase YouTube isn't installed on the user's device.

Yes, it's possible. With the class PackageInfo (ref: PackageInfo)
// The version number of this package, as specified by the <manifest> tag's
// versionCode attribute. Added in API level 1
public int versionCode
// The version name of this package, as specified by the <manifest> tag's
// versionName attribute. Added in API level 1
public String versionName
code:
PackageInfo pinfo = null;
pinfo = getPackageManager().getPackageInfo("com.google.android.youtube", 0);
int versionNumber = pinfo.versionCode;
String versionName = pinfo.versionName;

To get android os version at run time [duplicate]

Does anyone know how can I check the system version (e.g. 1.0, 2.2, etc.) programatically?

Example how to use it:
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.GINGERBREAD) {
// only for gingerbread and newer versions
}

Check android.os.Build.VERSION.
CODENAME: The current development codename, or the string "REL" if this is a release build.
INCREMENTAL: The internal value used by the underlying source control to represent this build.
RELEASE: The user-visible version string.

Build.Version is the place go to for this data. Here is a code snippet for how to format it.
public String getAndroidVersion() {
String release = Build.VERSION.RELEASE;
int sdkVersion = Build.VERSION.SDK_INT;
return "Android SDK: " + sdkVersion + " (" + release +")";
}
Looks like this "Android SDK: 19 (4.4.4)"

For checking device version which is greater than or equal to Marshmallow ,use this code.
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M){
}
for ckecking others just change the VERSION_CODES like,
K for kitkat,
L for loolipop
N for Nougat and so on...

Build.VERSION.RELEASE;
That will give you the actual numbers of your version; aka 2.3.3 or 2.2.
The problem with using Build.VERSION.SDK_INT is if you have a rooted phone or custom rom, you could have a none standard OS (aka my android is running 2.3.5) and that will return a null when using Build.VERSION.SDK_INT so Build.VERSION.RELEASE will work no matter what!

You can find out the Android version looking at Build.VERSION.
The documentation recommends you check Build.VERSION.SDK_INT against the values in Build.VERSION_CODES.
This is fine as long as you realise that Build.VERSION.SDK_INT was only introduced in API Level 4, which is to say Android 1.6 (Donut). So this won't affect you, but if you did want your app to run on Android 1.5 or earlier then you would have to use the deprecated Build.VERSION.SDK instead.

I can't comment on the answers, but there is a huge mistake in Kaushik's answer:
SDK_INT is not the same as system version but actually refers to API Level.
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH){
//this code will be executed on devices running ICS or later
}
The value Build.VERSION_CODES.ICE_CREAM_SANDWICH equals 14.
14 is the API level of Ice Cream Sandwich, while the system version is 4.0. So if you write 4.0, your code will be executed on all devices starting from Donut, because 4 is the API level of Donut (Build.VERSION_CODES.DONUT equals 4).
if(Build.VERSION.SDK_INT >= 4.0){
//this code will be executed on devices running on DONUT (NOT ICS) or later
}
This example is a reason why using 'magic number' is a bad habit.

Be aware that Build.VERSION.SDK_INT isn't reliable, it's mentioned by #Falcon165o and recently I ran into that one too.
So to get the String data (based on Android version list) of currently installed android, I made a code like this:
Java
//Current Android version data
public static String currentVersion(){
double release=Double.parseDouble(Build.VERSION.RELEASE.replaceAll("(\\d+[.]\\d+)(.*)","$1"));
String codeName="Unsupported";//below Jelly Bean
if(release >= 4.1 && release < 4.4) codeName = "Jelly Bean";
else if(release < 5) codeName="Kit Kat";
else if(release < 6) codeName="Lollipop";
else if(release < 7) codeName="Marshmallow";
else if(release < 8) codeName="Nougat";
else if(release < 9) codeName="Oreo";
else if(release < 10) codeName="Pie";
else if(release >= 10) codeName="Android "+((int)release);//since API 29 no more candy code names
return codeName+" v"+release+", API Level: "+Build.VERSION.SDK_INT;
}
Kotlin
fun currentVersion(): String {
val release = java.lang.Double.parseDouble(java.lang.String(Build.VERSION.RELEASE).replaceAll("(\\d+[.]\\d+)(.*)", "$1"))
var codeName = "Unsupported"//below Jelly Bean
if (release >= 4.1 && release < 4.4) codeName = "Jelly Bean"
else if (release < 5) codeName = "Kit Kat"
else if (release < 6) codeName = "Lollipop"
else if (release < 7) codeName = "Marshmallow"
else if (release < 8) codeName = "Nougat"
else if (release < 9) codeName = "Oreo"
else if (release < 10) codeName = "Pie"
else if (release >= 10) codeName = "Android "+(release.toInt())//since API 29 no more candy code names
return codeName + " v" + release + ", API Level: " + Build.VERSION.SDK_INT
}
Example of an output it produce:
Marshmallow v6.0, API Level: 23

For example, a feature only works for api21 up the following we fix bugs in api21 down
if(Build.VERSION.SDK_INT >= 21) {
//only api 21 above
}else{
//only api 21 down
}

if (Build.VERSION.SDK_INT >= ApiHelper.VERSION_CODES.HONEYCOMB_MR2) {
//do anything you like.
}

Use This method:
public static String getAndroidVersion() {
String versionName = "";
try {
versionName = String.valueOf(Build.VERSION.RELEASE);
} catch (Exception e) {
e.printStackTrace();
}
return versionName;
}

use this class
import android.os.Build;
/**
* Created by MOMANI on 2016/04/14.
*/
public class AndroidVersionUtil {
public static int getApiVersion() {
return android.os.Build.VERSION.SDK_INT;
}
public static boolean isApiVersionGraterOrEqual(int thisVersion) {
return android.os.Build.VERSION.SDK_INT >= thisVersion;
}
}

Given you have bash on your android device, you can use this bash function :
function androidCodeName {
androidRelease=$(getprop ro.build.version.release)
androidCodeName=$(getprop ro.build.version.codename)
# Time "androidRelease" x10 to test it as an integer
case $androidRelease in
[0-9].[0-9]|[0-9].[0-9].|[0-9].[0-9].[0-9]) androidRelease=$(echo $androidRelease | cut -d. -f1-2 | tr -d .);;
[0-9].) androidRelease=$(echo $androidRelease | sed 's/\./0/');;
[0-9]) androidRelease+="0";;
esac
[ -n "$androidRelease" ] && [ $androidCodeName = REL ] && {
# Do not use "androidCodeName" when it equals to "REL" but infer it from "androidRelease"
androidCodeName=""
case $androidRelease in
10) androidCodeName+=NoCodename;;
11) androidCodeName+="Petit Four";;
15) androidCodeName+=Cupcake;;
20|21) androidCodeName+=Eclair;;
22) androidCodeName+=FroYo;;
23) androidCodeName+=Gingerbread;;
30|31|32) androidCodeName+=Honeycomb;;
40) androidCodeName+="Ice Cream Sandwich";;
41|42|43) androidCodeName+="Jelly Bean";;
44) androidCodeName+=KitKat;;
50|51) androidCodeName+=Lollipop;;
60) androidCodeName+=Marshmallow;;
70|71) androidCodeName+=Nougat;;
80|81) androidCodeName+=Oreo;;
90) androidCodeName+=Pie;;
100) androidCodeName+=ToBeReleased;;
*) androidCodeName=unknown;;
esac
}
echo $androidCodeName
}

According to Android documentation:
Build.VERSION.RELEASE – "The user-visible version string. E.g., "1.0"
or "3.4b5" or "bananas""
In order to get a plain Android version (2.3, 5.1, 12.0, etc) I use this function:
private fun getVersion(): Float {
val release = Build.VERSION.RELEASE
val parsedVersion = "\\d+(\\.\\d+)?".toRegex()
.find(release)?.value
if (parsedVersion.isNullOrBlank()) return 0f
return try {
parsedVersion.toFloat()
} catch (e: Exception) {
0f
}
}

Categories

Resources