logo标签列表

从apk文件中获取minSdkVersion和targetSdkVersion

androidapkandroid-package-managers
19

我试图从设备存储的 apk 中获取 minSdkVersion 和 targetSdkVersion 的值。在此处讨论了获取其他详细信息的方法（链接），但是只有 ApplicationInfo 类中提供了 targetSdkVersion 的信息。是否可以通过方式来获取 minSdkVersion 的值而不需要提取apk文件并读取AndroidManifest.xml文件呢？

我猜无法从清单文件中获取minSDKVersion。 - Siddharth_Vyas
同一个问题，附带实际用例：https://dev59.com/d4vda4cB1Zd3GeqPXENW - OneWorld
8个回答
17

如果你只需要在下载的apk文件中查看minSdkVersion和targetSdkVersion以及其他许多细节信息，那么你只需要使用aapt工具，在终端中运行以下命令。

aapt dump badging yourapk.apk
你可以使用grep命令来搜索minSdk的sdkVersion。
aapt dump badging yourapk.apk | grep sdkVersion
这个应该得到更多的赞。这是一个很好的方式，可以发现 OP 想知道的内容，而不需要使用大量的额外工具或者瞎折腾。 - jerrythebum
1
对于任何试图找到aapt的人 - 一旦安装了Android开发工具，它位于/[用户主目录]Android/sdk/[sdk版本]/build-tools（Mac上）。由于某种原因，它不像adb那样自动添加到系统路径中。 - providencemac
10

使用aapt：

aapt list -a package.apk | grep SdkVersion

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

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

对于这个apk，minSdkVersion是0x3即3，targetSdkVersion是0xc即12。

下面是编辑后的答案：

然后您可以通过反向工程来获取源代码，按照以下步骤解码.apk文件：

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

第二步：
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.

步骤三：

现在打开另一个新文件夹

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应用程序中检索APK文件的minSdkVersion”。 - OneWorld
然后你可以通过逆向工程来实现，从apk中获取源代码。我已经编辑了我的回答。 - kuljeet singh
1
应将其标记为已接受的答案， 非常感谢， 在Windows中，请使用findstr而不是grep。 - Obtice
你救了我的命。谢谢伙计~ - JohnWatsonDev
感谢您的积极反馈。我在这里不是为了接受答案，而是为了回馈社区 :) - kuljeet singh
@OneWorld 我不明白为什么你会劫持别人的问题，并提出与原问题无关的要求。 - The incredible Jan
9
我不相信你能单独完成这个任务，也没有预先制作的API可用。目前读取和解析AndroidManifest的方法根本不考虑minSdkVersion。
为了在不使用现成函数的情况下检查您的apk文件，您最终需要手动将其添加到资产管理器中。而该方法标记为“不适用于应用程序”，据我的经验，这通常意味着从应用程序调用它并不是一个好主意。

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

如果您成功地进行了调用：
public final int addAssetPath(String path) {

从你的应用程序中，你应该能够通过解析XML文件获取minSdkVersion，考虑以下代码：

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

你应该能够使用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;
}

你可能需要使用反射调用来设置这个：
assets.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            Build.VERSION.RESOURCES_SDK_INT);

没有保证它能够正常工作（也不能保证不会对您的手机造成损害），但由于您正在创建一个新的AssetManager而不是依赖应用程序的AssetManager，所以操作应该是安全的。从快速查看C++代码来看，似乎它没有被添加到任何全局列表中。

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

我成功地测试了解决方案，并将静态方法“getMinSdkVersion”添加到代码示例中，使其可以立即使用。我给了这个解决方案赏金，因为它使用了相同的解析器，Android本身也使用了它。然而，在他们的注释中标记为“不应被应用程序使用”的未记录的API调用是一个问题。 - OneWorld
这个函数很少会失败，因为getAttributeName可能会返回一个空字符串（在安装的应用程序“TitaniumBackup”中找到：https://play.google.com/store/apps/details?id=com.keramidas.TitaniumBackup&hl=en）。我已经找到了一种解决方法，通过使用getAttributeNameResource来代替，并在这里写了关于它的文章：https://dev59.com/d4vda4cB1Zd3GeqPXENW#43603448。 - android developer
你如何获取apkPath？是通过ApplicationInfo.sourceDir吗？ - Someone Somewhere
5

将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读入一个byte[]以进行处理：
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

附注：我从以下网址中获取了这些方法：

如何以编程方式获取应用程序的.apk文件

以及这里：

如何解析.apk包内的AndroidManifest.xml文件

我成功地测试了解决方案。它能够解析整个AndroidManifest，非常令人印象深刻。感谢提供其他SO问题的链接。这导致了真正的问题，即如何解析AndroidManifest。与JohanShogun的答案相比，它使用了自己的解析器，而没有使用任何未记录的API调用。然而，该解析器在将来的新APK版本中可能会失败。与JohanShogun的答案不同，没有机制可以获取最适合和最新的解析器。 - OneWorld
2

使用随附在Android SDK中的apkanalyzer：

apkanalyzer manifest target-sdk your.apk

apkanalyzer manifest min-sdk your.apk

2

这可以很容易地完成。您需要遵循以下步骤：

  1. Apk Extractor 或输入命令 adb pull /data/app/package_name.apk
  2. Apk Tool jar 文件

现在输入以下命令：

apktool d package_name.apk

apk将被提取到当前目录，并且您将拥有一个可读的AndroidManifest文件。

无法满足“答案必须展示如何在Android应用程序中检索APK文件的minSdkVersion”的要求。 - OneWorld
@OneWorld Ruben Roy 在哪里要求这个？ - The incredible Jan
1

对于 Android API 24（Android N - 7.0）及以上版本，实际上您已经拥有它：

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

对于早期版本，您可以使用我在这里写的解决方法，或者使用相应的库。例如：

https://github.com/jaredrummler/APKParser

请注意，这个库可能需要大量的堆内存和时间，因此需要进行一些更改，以使其更适合这项任务，正如我在这里所建议的那样。
0
2018年的清单文件中还有最小SDK版本？！ - The incredible Jan
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接