Get minSdkVersion and targetSdkVersion from apk file

Question

I am trying to get the values of minSdkVersion and targetSdkVersion from an apk stored on the device. Getting other details are discussed here, but only the targetSdkVersion is available in the ApplicationInfo class. Can the minSdkVersion be obtained other than by extracting the apk file and reading AndroidManifest.xml?

Lacefield

I guess there is no way to obtain minSDKVersion from manifest file. – Marabou

Same question with an actual use case #30456358 – Doi

Answer 1

I do not believe this is possible to do on your own and there is no pre-made api for this. The current methods that read and parse the AndroidManifest do not consider minSdkVersion at all.

In order to check your apk file without using the ready made functions you end up needing to add it manually to the asset manager. And that method is marked with "Not for use by applications" which in my experience usually means that it's not a good idea to call it from an application.

http://androidxref.com/5.1.1_r6/xref/frameworks/base/core/java/android/content/res/AssetManager.java#612

If you do manage to call:

public final int addAssetPath(String path) {

From your application you should be able to get the minSdkVersion by parsing the XML file, consider this code:

private static final String ANDROID_MANIFEST_FILENAME = "AndroidManifest.xml";

....
method:

final int cookie = loadApkIntoAssetManager(assets, apkPath, flags);

Resources res = null;
XmlResourceParser parser = null;
try {
    res = new Resources(assets, mMetrics, null);
    assets.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            Build.VERSION.RESOURCES_SDK_INT);
    parser = assets.openXmlResourceParser(cookie, ANDROID_MANIFEST_FILENAME);

    final String[] outError = new String[1];
    final Package pkg = parseBaseApk(res, parser, flags, outError);
    if (pkg == null) {
        throw new PackageParserException(mParseError,
                apkPath + " (at " + parser.getPositionDescription() + "): " + outError[0]);
    }
}

Code: http://androidxref.com/5.1.1_r6/xref/frameworks/base/core/java/android/content/pm/PackageParser.java#863

Where you should be able to parse your AndroidManifest file using the XmlResourceParser and find the element for the minSdkVersion.

If you want to try it out yourself, just copy following static methods and call getMinSdkVersion(yourApkFile):

/**
 * Parses AndroidManifest of the given apkFile and returns the value of
 * minSdkVersion using undocumented API which is marked as
 * "not to be used by applications"
 * 
 * @param apkFile
 * @return minSdkVersion or -1 if not found in Manifest
 * @throws IOException
 * @throws XmlPullParserException
 */
public static int getMinSdkVersion(File apkFile) throws IOException,
        XmlPullParserException {

    XmlResourceParser parser = getParserForManifest(apkFile);
    while (parser.next() != XmlPullParser.END_DOCUMENT) {

        if (parser.getEventType() == XmlPullParser.START_TAG
                && parser.getName().equals("uses-sdk")) {
            for (int i = 0; i < parser.getAttributeCount(); i++) {
                if (parser.getAttributeName(i).equals("minSdkVersion")) {
                    return parser.getAttributeIntValue(i, -1);
                }
            }
        }
    }
    return -1;

}

/**
 * Tries to get the parser for the given apkFile from {@link AssetManager}
 * using undocumented API which is marked as
 * "not to be used by applications"
 * 
 * @param apkFile
 * @return
 * @throws IOException
 */
private static XmlResourceParser getParserForManifest(final File apkFile)
        throws IOException {
    final Object assetManagerInstance = getAssetManager();
    final int cookie = addAssets(apkFile, assetManagerInstance);
    return ((AssetManager) assetManagerInstance).openXmlResourceParser(
            cookie, "AndroidManifest.xml");
}

/**
 * Get the cookie of an asset using an undocumented API call that is marked
 * as "no to be used by applications" in its source code
 * 
 * @see <a
 *      href="http://androidxref.com/5.1.1_r6/xref/frameworks/base/core/java/android/content/res/AssetManager.java#612">AssetManager.java#612</a>
 * @return the cookie
 */
private static int addAssets(final File apkFile,
        final Object assetManagerInstance) {
    try {
        Method addAssetPath = assetManagerInstance.getClass().getMethod(
                "addAssetPath", new Class[] { String.class });
        return (Integer) addAssetPath.invoke(assetManagerInstance,
                apkFile.getAbsolutePath());
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return -1;
}

/**
 * Get {@link AssetManager} using reflection
 * 
 * @return
 */
private static Object getAssetManager() {
    Class assetManagerClass = null;
    try {
        assetManagerClass = Class
                .forName("android.content.res.AssetManager");
        Object assetManagerInstance = assetManagerClass.newInstance();
        return assetManagerInstance;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return null;
}

You may need a reflection call to set this as well:

assets.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            Build.VERSION.RESOURCES_SDK_INT);

No guarantees that it will work (nor that it won't be bad for your phone) the operation should be safe since you're creating a new AssetManager and not relying on the AssetManager for your application. From a quick look in the C++ code it seems that it's not being added to any global list.

Code: http://androidxref.com/5.1.1_r6/xref/frameworks/base/libs/androidfw/AssetManager.cpp#173

Linkman

I successfully tested the solution and added the static method getMinSdkVersion to the code example which makes it useable right away. I gave the bounty to this solution since the same parser is used, Android uses itself. However, using undocumented API calls that are marked as "not to be used by applications" in their comments are an issue. – Doi

This function rarely fails, as getAttributeName can return an empty string (Found this for an installed app "TitaniumBackup": play.google.com/store/apps/… ) . I've found a way to fix this by using getAttributeNameResource instead and wrote about it here: https://mcmap.net/q/665521/-android-getting-an-apks-minsdkversion-from-android-code-duplicate – Centripetal

how do you get apkPath ? Is it ApplicationInfo.sourceDir ? – Foremast

Answer 2

If you just need the minSdkVersion and targetSdkVersion and a whole lot of other details with the downloaded apk file. All you need is aapt tools and you can run the below command in the terminal.

aapt dump badging yourapk.apk

You can grep for sdkVersion for minSdk

aapt dump badging yourapk.apk | grep sdkVersion

Touraine

This should be upvoted more. Great way to discover what OP wanted to know without loads of extra tools/messing around. – Counterpressure

for anyone trying to find aapt - once android dev tools have been installed, it is located in/[user home]Android/sdk/[sdk version]/build-tools (for mac). For some reason it is not automatically added to the system path like adb is – Tymon

Answer 3

Use aapt:

aapt list -a package.apk | grep SdkVersion

You will see version numbers in hex. e.g.:

A: android:minSdkVersion(0x0101020c)=(type 0x10)0x3 A: android:targetSdkVersion(0x01010270)=(type 0x10)0xc

For this apk, minSdkVersion is 0x3 i.e. 3, and targetSdkVersion is 0xc i.e. 12.

Edited answer below :-

Then you can achieve it by reverse engineering you can get the source code from the apk by following steps Procedure for decoding .apk files, step-by-step method: Step 1:

Make a new folder and copy over the .apk file that you want to decode.

Now rename the extension of this .apk file to .zip (e.g. rename from filename.apk to filename.zip) and save it. Now you can access the classes.dex files, etc. At this stage you are able to see drawables but not xml and java files, so continue.

Step 2:

Now extract this .zip file in the same folder (or NEW FOLDER).

Download dex2jar and extract it to the same folder (or NEW FOLDER).

Move the classes.dex file into the dex2jar folder.

Now open command prompt and change directory to that folder (or NEW FOLDER). Then write d2j-dex2jar classes.dex (for mac terminal or ubuntu write ./d2j-dex2jar.sh classes.dex) and press enter. You now have the classes.dex.dex2jar file in the same folder.

Download java decompiler, double click on jd-gui, click on open file, and open classes.dex.dex2jar file from that folder: now you get class files.

Save all of these class files (In jd-gui, click File -> Save All Sources) by src name. At this stage you get the java source but the .xml files are still unreadable, so continue.

Step 3:

Now open another new folder

Put in the .apk file which you want to decode

Download the latest version of apktool AND apktool install window (both can be downloaded from the same link) and place them in the same folder

Download framework-res.apk and put it in the same folder (Not all apk file need this file, but it doesn't hurt)

Open a command window

Navigate to the root directory of APKtool and type the following command: apktool if framework-res.apk

apktool d myApp.apk (where myApp.apk denotes the filename that you want to decode)

now you get a file folder in that folder and can easily read the apk's xml files. Step 4:

It's not any step just copy contents of both folder(in this case both new folder)to the single one

and enjoy the source code...

Michaelson

Does not fulfill the requirement "answer must show how to retrieve minSdkVersion of an APK file within an Android app" – Doi

Then you can achieve it by reverse engineering you can get the source code from the apk . Edited my answer – Michaelson

That should be marked as accepted answer, tnx a lot, in windows, use findstr instead of grep – Checkerboard

You saved my life. Thanks buddy~ – Teena

Thanks for your positive feedback.I am not here for answer acceptance I am here for giving back to community :) – Michaelson

@Doi I don't understand why you hijack other people's questions and make demands that don't result from the original question. – Sulcus

Answer 4

Copy the apk into a new directory:

final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
final List pkgAppsList = getPackageManager().queryIntentActivities(mainIntent, 0);
for (Object object : pkgAppsList) {
   ResolveInfo info = (ResolveInfo) object;
   File file = new File(info.activityInfo.applicationInfo.publicSourceDir);
   // Copy the .apk file to wherever
}

The following method reads the AndroidManifest into a byte[] for processing:

public void getIntents(String path_to_apk) {
 try {
       JarFile jf = new JarFile(path_to_apk);
       InputStream is = jf.getInputStream(jf.getEntry("AndroidManifest.xml"));
       byte[] xml = new byte[is.available()];
       int br = is.read(xml);
       //Tree tr = TrunkFactory.newTree();
       decompressXML(xml);
       //prt("XML\n"+tr.list());
  } catch (Exception ex) {
     console.log("getIntents, ex: "+ex);  ex.printStackTrace();
  }
} 

Finally decompress the android manifest's xml:

  // decompressXML -- Parse the 'compressed' binary form of Android XML docs 
// such as for AndroidManifest.xml in .apk files
public static int endDocTag = 0x00100101;
public static int startTag =  0x00100102;
public static int endTag =    0x00100103;
public void decompressXML(byte[] xml) {
// Compressed XML file/bytes starts with 24x bytes of data,
// 9 32 bit words in little endian order (LSB first):
//   0th word is 03 00 08 00
//   3rd word SEEMS TO BE:  Offset at then of StringTable
//   4th word is: Number of strings in string table
// WARNING: Sometime I indiscriminently display or refer to word in 
//   little endian storage format, or in integer format (ie MSB first).
int numbStrings = LEW(xml, 4*4);

// StringIndexTable starts at offset 24x, an array of 32 bit LE offsets
// of the length/string data in the StringTable.
int sitOff = 0x24;  // Offset of start of StringIndexTable

// StringTable, each string is represented with a 16 bit little endian 
// character count, followed by that number of 16 bit (LE) (Unicode) chars.
int stOff = sitOff + numbStrings*4;  // StringTable follows StrIndexTable

// XMLTags, The XML tag tree starts after some unknown content after the
// StringTable.  There is some unknown data after the StringTable, scan
// forward from this point to the flag for the start of an XML start tag.
int xmlTagOff = LEW(xml, 3*4);  // Start from the offset in the 3rd word.
// Scan forward until we find the bytes: 0x02011000(x00100102 in normal int)
for (int ii=xmlTagOff; ii<xml.length-4; ii+=4) {
  if (LEW(xml, ii) == startTag) { 
    xmlTagOff = ii;  break;
  }
} // end of hack, scanning for start of first start tag

// XML tags and attributes:
// Every XML start and end tag consists of 6 32 bit words:
//   0th word: 02011000 for startTag and 03011000 for endTag 
//   1st word: a flag?, like 38000000
//   2nd word: Line of where this tag appeared in the original source file
//   3rd word: FFFFFFFF ??
//   4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS
//   5th word: StringIndex of Element Name
//   (Note: 01011000 in 0th word means end of XML document, endDocTag)

// Start tags (not end tags) contain 3 more words:
//   6th word: 14001400 meaning?? 
//   7th word: Number of Attributes that follow this tag(follow word 8th)
//   8th word: 00000000 meaning??

// Attributes consist of 5 words: 
//   0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF
//   1st word: StringIndex of Attribute Name
//   2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId used
//   3rd word: Flags?
//   4th word: str ind of attr value again, or ResourceId of value

// TMP, dump string table to tr for debugging
//tr.addSelect("strings", null);
//for (int ii=0; ii<numbStrings; ii++) {
//  // Length of string starts at StringTable plus offset in StrIndTable
//  String str = compXmlString(xml, sitOff, stOff, ii);
//  tr.add(String.valueOf(ii), str);
//}
//tr.parent();

// Step through the XML tree element tags and attributes
int off = xmlTagOff;
int indent = 0;
int startTagLineNo = -2;
while (off < xml.length) {
  int tag0 = LEW(xml, off);
  //int tag1 = LEW(xml, off+1*4);
  int lineNo = LEW(xml, off+2*4);
  //int tag3 = LEW(xml, off+3*4);
  int nameNsSi = LEW(xml, off+4*4);
  int nameSi = LEW(xml, off+5*4);

  if (tag0 == startTag) { // XML START TAG
    int tag6 = LEW(xml, off+6*4);  // Expected to be 14001400
    int numbAttrs = LEW(xml, off+7*4);  // Number of Attributes to follow
    //int tag8 = LEW(xml, off+8*4);  // Expected to be 00000000
    off += 9*4;  // Skip over 6+3 words of startTag data
    String name = compXmlString(xml, sitOff, stOff, nameSi);
    //tr.addSelect(name, null);
    startTagLineNo = lineNo;

    // Look for the Attributes
    StringBuffer sb = new StringBuffer();
    for (int ii=0; ii<numbAttrs; ii++) {
      int attrNameNsSi = LEW(xml, off);  // AttrName Namespace Str Ind, or FFFFFFFF
      int attrNameSi = LEW(xml, off+1*4);  // AttrName String Index
      int attrValueSi = LEW(xml, off+2*4); // AttrValue Str Ind, or FFFFFFFF
      int attrFlags = LEW(xml, off+3*4);  
      int attrResId = LEW(xml, off+4*4);  // AttrValue ResourceId or dup AttrValue StrInd
      off += 5*4;  // Skip over the 5 words of an attribute

      String attrName = compXmlString(xml, sitOff, stOff, attrNameSi);
      String attrValue = attrValueSi!=-1
        ? compXmlString(xml, sitOff, stOff, attrValueSi)
        : "resourceID 0x"+Integer.toHexString(attrResId);
      sb.append(" "+attrName+"=\""+attrValue+"\"");
      //tr.add(attrName, attrValue);
    }
    prtIndent(indent, "<"+name+sb+">");
    indent++;

  } else if (tag0 == endTag) { // XML END TAG
    indent--;
    off += 6*4;  // Skip over 6 words of endTag data
    String name = compXmlString(xml, sitOff, stOff, nameSi);
    prtIndent(indent, "</"+name+">  (line "+startTagLineNo+"-"+lineNo+")");
    //tr.parent();  // Step back up the NobTree

  } else if (tag0 == endDocTag) {  // END OF XML DOC TAG
    break;

  } else {
    prt("  Unrecognized tag code '"+Integer.toHexString(tag0)
      +"' at offset "+off);
    break;
  }
} // end of while loop scanning tags and attributes of XML tree
prt("    end at offset "+off);
} // end of decompressXML


public String compXmlString(byte[] xml, int sitOff, int stOff, int strInd) {
  if (strInd < 0) return null;
  int strOff = stOff + LEW(xml, sitOff+strInd*4);
  return compXmlStringAt(xml, strOff);
}


public static String spaces = "                                             ";
public void prtIndent(int indent, String str) {
  prt(spaces.substring(0, Math.min(indent*2, spaces.length()))+str);
}


// compXmlStringAt -- Return the string stored in StringTable format at
// offset strOff.  This offset points to the 16 bit string length, which 
// is followed by that number of 16 bit (Unicode) chars.
public String compXmlStringAt(byte[] arr, int strOff) {
  int strLen = arr[strOff+1]<<8&0xff00 | arr[strOff]&0xff;
  byte[] chars = new byte[strLen];
  for (int ii=0; ii<strLen; ii++) {
    chars[ii] = arr[strOff+2+ii*2];
  }
  return new String(chars);  // Hack, just use 8 byte chars
} // end of compXmlStringAt


// LEW -- Return value of a Little Endian 32 bit word from the byte array
//   at offset off.
public int LEW(byte[] arr, int off) {
  return arr[off+3]<<24&0xff000000 | arr[off+2]<<16&0xff0000
    | arr[off+1]<<8&0xff00 | arr[off]&0xFF;
} // end of LEW

P.S. I have retrieved these methods from here:

How to get the .apk file of an application programmatically

And here:

How to parse the AndroidManifest.xml file inside an .apk package

Germen

I successfully tested the solution. It parses the whole AndroidManifest pretty impressive. Thanks for providing the links to the other SO-issues. That lead to the real problem which is parsing the AndroidManifest somehow. It uses its own parser compared to JohanShogun's answer while no undocumented API calls are used. However, the parser could fail some time in future at newer APK versions. There is no mechanism to get the best suiteable and most current parser as in JohanShogun's answer. – Doi

Answer 5

This can be done easily. You need to following

1. Apk Extractor or type command adb pull /data/app/package_name.apk
2. Apk Tool jar file

Now type the command

apktool d package_name.apk

apk will be extracted to the current directory and you will be having a readable AndroidManfiest file

Lo

Does not fulfill the requirement "answer must show how to retrieve minSdkVersion of an APK file within an Android app" – Doi

@Doi Where did Ruben Roy ask for this? – Sulcus

Answer 6

Use the apkanalyzer shipped with the Android SDK:

apkanalyzer manifest target-sdk your.apk

apkanalyzer manifest min-sdk your.apk

Joanajoane

Answer 7

For Android API 24 (Android N - 7.0) and above, you actually do have it:

https://developer.android.com/reference/android/content/pm/ApplicationInfo.html#minSdkVersion

For earlier versions, you can use a workaround as I've written here, or a library for this. For example:

https://github.com/jaredrummler/APKParser

Do note that this library might take a lot of heap memory and time, so it needs some changes in order to make it more optimized for this task, as I've suggested here.

Centripetal

Answer 8

Don't need any tool, there is an on-device app to read the manifest

https://play.google.com/store/apps/details?id=jp.susatthi.ManifestViewer&hl=en

The downside is, that if the minSdkVersion has not been declared in the manifest and in the build.gradle file instead it will not show here.

Counterpressure

Min SDK in Manifest in 2018?! – Sulcus