Android 从apk文件获取minSdkVersion和targetSdkVersion

我试图从设备上存储的apk获取

minSdkVersion

和

targetSdkVersion

的值。讨论了获取其他细节，但仅讨论了

---

在

ApplicationInfo

类中提供。除了提取apk文件并读取AndroidManifest.xml之外，是否可以获得

minSdkVersion

？

我认为这不可能由您自己完成，并且没有为此预先制作的api。当前读取和解析ANDROIDMANT的方法根本不考虑MimSDKVIEW。

为了在不使用现成功能的情况下检查apk文件，您最终需要将其手动添加到asset manager。该方法标有“不供应用程序使用”，根据我的经验，这通常意味着从应用程序调用它不是一个好主意

如果您确实设法拨打：

public final int addAssetPath(String path) {

从应用程序中，您应该能够通过解析XML文件来获得MimSDKVIEW，请考虑此代码：

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

代码：

您应该能够使用XmlResourceParser解析AndroidManifest文件，并找到minSdkVersion的元素

如果您想自己尝试，只需复制以下静态方法并调用

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

不保证它会工作（也不保证它不会对您的手机造成不良影响）。操作应该是安全的，因为您正在创建一个新的AssetManager，并且应用程序不依赖AssetManager。从C++代码中的快速查看看来，它没有被添加到任何全局列表。 代码：

---

将apk复制到新目录中：

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
}

以下方法将AndroidManifest读入字节[]进行处理：

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

最后解压缩android清单的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

//解压缩XML——解析Android XML文档的“压缩”二进制形式
//例如.apk文件中的AndroidManifest.xml
公共静态int-endDocTag=0x00100101；
公共静态int startTag=0x00100102；
公共静态int-endTag=0x00100103；
公共void解压缩xml（字节[]xml）{
//压缩XML文件/字节以24倍字节的数据开始，
//9个32位字的小端顺序（LSB优先）：
//第0个字是03 00 08 00
//第三个字似乎是：StringTable的偏移量
//第四个字是：字符串表中的字符串数
//警告：有时我不加区分地显示或引用中的单词
//小端存储格式，或整数格式（即MSB优先）。
int numbStrings=LEW（xml，4*4）；
//StringIndexTable从偏移量24x开始，偏移量为32位LE偏移量的数组
//StringTable中长度/字符串数据的。
int sitOff=0x24；//StringIndexTable开始的偏移量
//StringTable，每个字符串用一个16位的小尾端表示
//字符计数，后跟16位（LE）（Unicode）字符数。
int stOff=sitOff+numbStrings*4；//StringTable后面是StrIndexTable
//XMLTags，XML标记树在
//StringTable。StringTable扫描后有一些未知数据
//从这一点转发到XML开始标记的开始标志。
int xmlTagOff=LEW（xml，3*4）；//从第三个字的偏移量开始。
//向前扫描，直到找到字节：0x02011000（正常整数中的x00100102）
对于（int ii=xmlTagOff；ii这可以很容易地完成

或键入命令adb pull/data/app/package_name.apk
jar文件
现在键入命令

apktool d package_name.apk

apk将被提取到当前目录，您将拥有一个可读的AndroidManfiest文件
使用aapt:

aapt列表-一个package.apk | grep SdkVersion

您将看到十六进制的版本号。例如：

A:android:minSdkVersion（0x0101020c）=（类型0x10）0x3
A:android:targetSdkVersion（0x01010270）=（类型0x10）0xc

对于该apk，minSdkVersion为0x3，即3，targetSdkVersion为0xc，即12

下面编辑的答案：-

然后，您可以通过逆向工程来实现它。您可以通过以下步骤从apk获取源代码
解码.apk文件的步骤，分步方法：
步骤1：

步骤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.

步骤3：

现在打开另一个新文件夹

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)

现在，您在该文件夹中获得了一个文件文件夹，可以轻松地读取apk的xml文件。
步骤4：

不需要任何步骤，只需将两个文件夹（在本例中为两个新文件夹）的内容复制到单个文件夹即可

并享受源代码…
对于Android API 24（Android N-7.0）及以上版本，您确实拥有它：


对于早期版本，您可以使用我编写的变通方法，或者使用库。例如：


请注意，这个库可能会占用大量堆内存和时间，因此，正如我所建议的，它需要进行一些更改，以使其更适合此任务。
如果您只需要minSdkVersion和targetSdkVersion以及下载的apk文件的所有其他详细信息。您只需要aapt工具，就可以运行以下命令在候机楼

aapt dump badging yourapk.apk

您可以为minSdk的sdkVersion进行grep

aapt dump badging yourapk.apk | grep sdkVersion

不需要任何工具，有一个设备上的应用程序来读取清单


缺点是，如果未在清单和build.gradle文件中声明minSdkVersion，它将不会显示在此处。
使用Android SDK附带的
apkanalyzer
：

apkanalyzer清单目标sdk您的.apk

apkanalyzer manifest min sdk您的.apk
我想没有办法从清单文件中获取minSDKVersion。实际用例中的同一个问题不符合要求“答案必须显示如何在Android应用程序中检索apk文件的minSDKVersion”不符合要求“答案必须显示如何在Android应用程序中检索APK文件的Minsdk版本”，然后您可以通过反向工程实现它，您可以从APK获取源代码。已编辑的我的答案应标记为
aapt dump badging yourapk.apk

aapt dump badging yourapk.apk | grep sdkVersion