本文介绍了即使使用InputStream，如何获取APK文件的可靠且有效的清单内容?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我想获取有关 APK 文件(包括拆分的 APK 文件)的信息，即使它们位于压缩的 zip 文件中(无需对其进行解压缩).就我而言，这包括各种内容，例如包名称、版本代码、版本名称、应用标签、应用图标，以及它是否是拆分的 APK 文件.
I wanted to get information about APK files(including split APK files), even if they are inside compressed zip files (without de-compressing them). In my case, this include various things, such as package name, version-code, version-name, app-label, app-icon, and if it's a split APK file or not.
请注意，我想在 Android 应用程序中完成所有操作，而不是使用 PC，因此可能无法使用某些工具.
Do note that I want to do it all inside an Android app, not using a PC, so some tools might not be possible to be used.
这意味着我不能使用 getPackageArchiveInfo 函数，因为此函数需要 APK 文件的路径，并且仅适用于非拆分 APK 文件.
This means I can't use the getPackageArchiveInfo function, as this function requires a path to the APK file, and works only on non-split-apk files.
简而言之，没有框架函数可以做到这一点，所以我必须找到一种方法，通过进入压缩文件，使用 InputStream 作为输入在函数中解析它.
In short, there is no framework function to do it, so I have to find a way of how to do it by going into the zipped file, using the InputStream as input for parsing it in a function.
网上有各种解决方案，包括 Android 之外的解决方案，但我不知道哪一种是稳定且适用于所有情况的.许多甚至适用于 Android(例如此处)，但可能解析失败，可能需要文件路径而不是 Uri/InputStream.
There are various solutions online, including outside of Android, but I don't know of one that is stable and works for all cases. Many might be good even for Android (example here), but might fail parsing and might require a file path instead of Uri/InputStream.
我在 StackOverflow 上找到了 this，但遗憾的是根据我的测试，它始终生成内容，但在极少数情况下，它不是有效的 XML 内容.
I've found this on StackOverflow, but sadly according to my tests, it always generates content, but in some rare cases it's not a valid XML content.
到目前为止，我发现解析器无法解析这些应用程序包名称及其版本代码，因为输出的 XML 内容无效:
So far, I've found these apps package names and their version codes that the parser fails to parse, as the output XML content is invalid:
- com.farproc.wifi.analyzer 139
- com.teslacoilsw.launcherclientproxy 2
- com.hotornot.app 3072
- android 29(即Android 系统"系统应用本身)
- com.google.android.videos 41300042
- com.facebook.katana 201518851
- com.keramidas.TitaniumBackupPro 10
- com.google.android.apps.tachyon 2985033
- com.google.android.apps.photos 3594753
使用 XML 查看器 和 XML 验证器，这里是问题这些应用:
Using an XML viewer and XML validator, here are the issues with these apps:
- 对于#1、#2，我得到了一个非常奇怪的内容，从
<mnfs开始. - 对于 #3，它不喜欢&"在
<activity theme="resourceID 0x7f13000b" label="Features & Tests" ... - 对于#4，它最后错过了manifest"的结束标签.
- 对于 #5，它错过了多个结束标签，至少是意图过滤器"、接收器"和清单".也许更多.
- 对于 #6，出于某种原因，它在application"标签中获得了两次allowBackup"属性.
- 对于#7，它在清单标签中得到一个没有属性的值:
<manifest versionCode="resourceID 0xa" ="1.3.2". - 对于#8，它在获得一些uses-feature"标签后遗漏了很多内容，并且没有manifest"的结束标签.
- 对于#9，它在获得一些uses-permission"标签后遗漏了很多内容，并且没有manifest"的结束标签
令人惊讶的是，我没有发现拆分 APK 文件有任何问题.仅适用于主要 APK 文件.
Surprisingly, I didn't find any issue with split APK files. Only with main APK files.
这是代码(也可以在此处):
Here's the code (also available here) :
MainActivity .kt
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
thread {
val problematicApkFiles = HashMap<ApplicationInfo, HashSet<String>>()
val installedApplications = packageManager.getInstalledPackages(0)
val startTime = System.currentTimeMillis()
for ((index, packageInfo) in installedApplications.withIndex()) {
val applicationInfo = packageInfo.applicationInfo
val packageName = packageInfo.packageName
// Log.d("AppLog", "$index/${installedApplications.size} parsing app $packageName ${packageInfo.versionCode}...")
val mainApkFilePath = applicationInfo.publicSourceDir
val parsedManifestOfMainApkFile =
try {
val parsedManifest = ManifestParser.parse(mainApkFilePath)
if (parsedManifest?.isSplitApk != false)
Log.e("AppLog", "$packageName - parsed normal APK, but failed to identify it as such")
parsedManifest?.manifestAttributes
} catch (e: Exception) {
Log.e("AppLog", e.toString())
null
}
if (parsedManifestOfMainApkFile == null) {
problematicApkFiles.getOrPut(applicationInfo, { HashSet() }).add(mainApkFilePath)
Log.e("AppLog", "$packageName - failed to parse main APK file $mainApkFilePath")
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
applicationInfo.splitPublicSourceDirs?.forEach {
val parsedManifestOfSplitApkFile =
try {
val parsedManifest = ManifestParser.parse(it)
if (parsedManifest?.isSplitApk != true)
Log.e("AppLog", "$packageName - parsed split APK, but failed to identify it as such")
parsedManifest?.manifestAttributes
} catch (e: Exception) {
Log.e("AppLog", e.toString())
null
}
if (parsedManifestOfSplitApkFile == null) {
Log.e("AppLog", "$packageName - failed to parse main APK file $it")
problematicApkFiles.getOrPut(applicationInfo, { HashSet() }).add(it)
}
}
}
val endTime = System.currentTimeMillis()
Log.d("AppLog", "done parsing. number of files we failed to parse:${problematicApkFiles.size} time taken:${endTime - startTime} ms")
if (problematicApkFiles.isNotEmpty()) {
Log.d("AppLog", "list of files that we failed to get their manifest:")
for (entry in problematicApkFiles) {
Log.d("AppLog", "packageName:${entry.key.packageName} , files:${entry.value}")
}
}
}
}
}
ManifestParser.kt
class ManifestParser{
var isSplitApk: Boolean? = null
var manifestAttributes: HashMap<String, String>? = null
companion object {
fun parse(file: File) = parse(java.io.FileInputStream(file))
fun parse(filePath: String) = parse(File(filePath))
fun parse(inputStream: InputStream): ManifestParser? {
val result = ManifestParser()
val manifestXmlString = ApkManifestFetcher.getManifestXmlFromInputStream(inputStream)
?: return null
val factory: DocumentBuilderFactory = DocumentBuilderFactory.newInstance()
val builder: DocumentBuilder = factory.newDocumentBuilder()
val document: Document? = builder.parse(manifestXmlString.byteInputStream())
if (document != null) {
document.documentElement.normalize()
val manifestNode: Node? = document.getElementsByTagName("manifest")?.item(0)
if (manifestNode != null) {
val manifestAttributes = HashMap<String, String>()
for (i in 0 until manifestNode.attributes.length) {
val node = manifestNode.attributes.item(i)
manifestAttributes[node.nodeName] = node.nodeValue
}
result.manifestAttributes = manifestAttributes
}
}
result.manifestAttributes?.let {
result.isSplitApk = (it["android:isFeatureSplit"]?.toBoolean()
?: false) || (it.containsKey("split"))
}
return result
}
}
}
ApkManifestFetcher.kt
object ApkManifestFetcher {
fun getManifestXmlFromFile(apkFile: File) = getManifestXmlFromInputStream(FileInputStream(apkFile))
fun getManifestXmlFromFilePath(apkFilePath: String) = getManifestXmlFromInputStream(FileInputStream(File(apkFilePath)))
fun getManifestXmlFromInputStream(ApkInputStream: InputStream): String? {
ZipInputStream(ApkInputStream).use { zipInputStream: ZipInputStream ->
while (true) {
val entry = zipInputStream.nextEntry ?: break
if (entry.name == "AndroidManifest.xml") {
// zip.getInputStream(entry).use { input ->
return decompressXML(zipInputStream.readBytes())
// }
}
}
}
return null
}
/**
* Binary XML doc ending Tag
*/
private var endDocTag = 0x00100101
/**
* Binary XML start Tag
*/
private var startTag = 0x00100102
/**
* Binary XML end Tag
*/
private var endTag = 0x00100103
/**
* Reference var for spacing
* Used in prtIndent()
*/
private var spaces = " "
/**
* Parse the 'compressed' binary form of Android XML docs
* such as for AndroidManifest.xml in .apk files
* Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689
*
* @param xml Encoded XML content to decompress
*/
private fun decompressXML(xml: ByteArray): String {
val resultXml = StringBuilder()
// 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).
val 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.
val 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.
val 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.
var 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)
run {
var ii = xmlTagOff
while (ii < xml.size - 4) {
if (lew(xml, ii) == startTag) {
xmlTagOff = ii
break
}
ii += 4
}
} // 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
var off = xmlTagOff
var indent = 0
// var startTagLineNo = -2
while (off < xml.size) {
val tag0 = lew(xml, off)
//int tag1 = LEW(xml, off+1*4);
// val lineNo = lew(xml, off + 2 * 4)
//int tag3 = LEW(xml, off+3*4);
// val nameNsSi = lew(xml, off + 4 * 4)
val nameSi = lew(xml, off + 5 * 4)
if (tag0 == startTag) { // XML START TAG
// val tag6 = lew(xml, off + 6 * 4) // Expected to be 14001400
val 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
val name = compXmlString(xml, sitOff, stOff, nameSi)
//tr.addSelect(name, null);
// startTagLineNo = lineNo
// Look for the Attributes
val sb = StringBuffer()
for (ii in 0 until numbAttrs) {
// val attrNameNsSi = lew(xml, off) // AttrName Namespace Str Ind, or FFFFFFFF
val attrNameSi = lew(xml, off + 1 * 4) // AttrName String Index
val attrValueSi = lew(xml, off + 2 * 4) // AttrValue Str Ind, or FFFFFFFF
// val attrFlags = lew(xml, off + 3 * 4)
val attrResId = lew(xml, off + 4 * 4) // AttrValue ResourceId or dup AttrValue StrInd
off += 5 * 4 // Skip over the 5 words of an attribute
val attrName = compXmlString(xml, sitOff, stOff, attrNameSi)
val attrValue = if (attrValueSi != -1)
compXmlString(xml, sitOff, stOff, attrValueSi)
else
"resourceID 0x" + Integer.toHexString(attrResId)
sb.append(" $attrName=\"$attrValue\"")
//tr.add(attrName, attrValue);
}
resultXml.append(prtIndent(indent, "<$name$sb>"))
indent++
} else if (tag0 == endTag) { // XML END TAG
indent--
off += 6 * 4 // Skip over 6 words of endTag data
val name = compXmlString(xml, sitOff, stOff, nameSi)
resultXml.append(prtIndent(indent, "</$name>")) // (line $startTagLineNo-$lineNo)
//tr.parent(); // Step back up the NobTree
} else if (tag0 == endDocTag) { // END OF XML DOC TAG
break
} else {
// println(" Unrecognized tag code '" + Integer.toHexString(tag0)
// + "' at offset " + off
// )
break
}
} // end of while loop scanning tags and attributes of XML tree
// println(" end at offset $off")
return resultXml.toString()
} // end of decompressXML
/**
* Tool Method for decompressXML();
* Compute binary XML to its string format
* Source: Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689
*
* @param xml Binary-formatted XML
* @param sitOff
* @param stOff
* @param strInd
* @return String-formatted XML
*/
private fun compXmlString(xml: ByteArray, @Suppress("SameParameterValue") sitOff: Int, stOff: Int, strInd: Int): String? {
if (strInd < 0) return null
val strOff = stOff + lew(xml, sitOff + strInd * 4)
return compXmlStringAt(xml, strOff)
}
/**
* Tool Method for decompressXML();
* Apply indentation
*
* @param indent Indentation level
* @param str String to indent
* @return Indented string
*/
private fun prtIndent(indent: Int, str: String): String {
return spaces.substring(0, min(indent * 2, spaces.length)) + str
}
/**
* Tool method for decompressXML()
* 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.
*
* @param arr StringTable array
* @param strOff Offset to get string from
* @return String from StringTable at offset strOff
*/
private fun compXmlStringAt(arr: ByteArray, strOff: Int): String {
val strLen = (arr[strOff + 1] shl (8 and 0xff00)) or (arr[strOff].toInt() and 0xff)
val chars = ByteArray(strLen)
for (ii in 0 until strLen) {
chars[ii] = arr[strOff + 2 + ii * 2]
}
return String(chars) // Hack, just use 8 byte chars
} // end of compXmlStringAt
/**
* Return value of a Little Endian 32 bit word from the byte array
* at offset off.
*
* @param arr Byte array with 32 bit word
* @param off Offset to get word from
* @return Value of Little Endian 32 bit word specified
*/
private fun lew(arr: ByteArray, off: Int): Int {
return (arr[off + 3] shl 24 and -0x1000000 or ((arr[off + 2] shl 16) and 0xff0000)
or (arr[off + 1] shl 8 and 0xff00) or (arr[off].toInt() and 0xFF))
} // end of LEW
private infix fun Byte.shl(i: Int): Int = (this.toInt() shl i)
// private infix fun Int.shl(i: Int): Int = (this shl i)
}
问题
- 我怎么会得到一些 APK 清单文件的无效 XML 内容(因此它们的 XML 解析失败)?
- 我怎样才能让它一直工作?
- 是否有更好的方法将清单文件解析为有效的 XML?也许是更好的替代方案，它可以处理各种 APK 文件，包括压缩文件，而无需解压?
推荐答案
ApkManifestFetcher 似乎不能处理所有情况，例如文本(标签之间)和命名空间声明，也许还有一个其他几件事.下面是 ApkManifestFetcher 的返工，它可以处理我手机上的所有 300 多个 APK，但 Netflix APK 出现了一些空白属性.
It seems that ApkManifestFetcher doesn't handle all cases such as text (between tags) and name space declarations and, maybe, a few other things. Below is a rework of ApkManifestFetcher that handles all 300+ APKs on my phone except for the Netflix APK which is coming up with some blank attributes.
我不再相信以 <mnfs 开头的文件与混淆有任何关系，而是使用 UTF-8 而不是应用程序假定的 UTF-16(16 位 vs 8位).重新设计的应用可处理 UTF-8 编码并可以解析这些文件.
I no longer believe that the files that start with <mnfs have anything to do with obfuscation but are encoded using UTF-8 rather than UTF-16 which the app assumes (16 bits vs 8 bits). The reworked app handles UTF-8 encoding and can parse these files.
如上所述，尽管返工可以跳过名称空间，但原始类或此返工没有正确处理名称空间.代码中的注释对此进行了一些描述.
As mentioned above, name spaces are not handled correctly by the original class or this rework although the rework can skip past them. Comments in the code describe this a little.
也就是说，下面的代码对于某些应用程序来说可能已经足够好了.更好的做法是使用 apktool 中的代码，尽管这些代码似乎能够处理所有 APK.
That said, the code below may be good enough for certain applications. The better, although longer, course of action would be to use code from apktool which seems to be able to handle all APKs.
ApkManifestFetcher
object ApkManifestFetcher {
fun getManifestXmlFromFile(apkFile: File) =
getManifestXmlFromInputStream(FileInputStream(apkFile))
fun getManifestXmlFromFilePath(apkFilePath: String) =
getManifestXmlFromInputStream(FileInputStream(File(apkFilePath)))
fun getManifestXmlFromInputStream(ApkInputStream: InputStream): String? {
ZipInputStream(ApkInputStream).use { zipInputStream: ZipInputStream ->
while (true) {
val entry = zipInputStream.nextEntry ?: break
if (entry.name == "AndroidManifest.xml") {
return decompressXML(zipInputStream.readBytes())
}
}
}
return null
}
/**
* Binary XML name space starts
*/
private const val startNameSpace = 0x00100100
/**
* Binary XML name space ends
*/
private const val endNameSpace = 0x00100101
/**
* Binary XML start Tag
*/
private const val startTag = 0x00100102
/**
* Binary XML end Tag
*/
private const val endTag = 0x00100103
/**
* Binary XML text Tag
*/
private const val textTag = 0x00100104
/*
* Flag for UTF-8 encoded file. Default is UTF-16.
*/
private const val FLAG_UTF_8 = 0x00000100
/**
* Reference var for spacing
* Used in prtIndent()
*/
private const val spaces = " "
// Flag if the manifest is in UTF-8 but we don't really handle it.
private var mIsUTF8 = false
/**
* Parse the 'compressed' binary form of Android XML docs
* such as for AndroidManifest.xml in .apk files
* Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689
*
* @param xml Encoded XML content to decompress
*/
private fun decompressXML(xml: ByteArray): String {
val resultXml = StringBuilder()
/*
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 (Magic number) 08 00 (header size words 0-1)
1st word is the size of the compressed XML. This should equal size of xml array.
2nd word is 01 00 (Magic number) 1c 00 (header size words 2-8)
3rd word is offset of byte after string table
4th word is number of strings in string table
5th word is style count
6th word are flags
7th word string table offset
8th word is styles offset
[string index table (little endian offset into string table)]
[string table (two byte length followed by text for each entry UTF-16, nul)]
*/
mIsUTF8 = (lew(xml, 24) and FLAG_UTF_8) != 0
val 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.
val 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.
val 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.
var 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)
run {
var ii = xmlTagOff
while (ii < xml.size - 4) {
if (lew(xml, ii) == startTag) {
xmlTagOff = ii
break
}
ii += 4
}
}
/*
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: 0xFFFFFFFF ??
4th word: StringIndex of NameSpace name, or 0xFFFFFF 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 0xFFFFFF
1st word: StringIndex of Attribute Name
2nd word: StringIndex of Attribute Value, or 0xFFFFFFF if ResourceId used
3rd word: Flags?
4th word: str ind of attr value again, or ResourceId of value
Text blocks consist of 7 words
0th word: The text tag (0x00100104)
1st word: Size of the block (28 bytes)
2nd word: Line number
3rd word: 0xFFFFFFFF
4th word: Index into the string table
5th word: Unknown
6th word: Unknown
startNameSpace blocks consist of 6 words
0th word: The startNameSpace tag (0x00100100)
1st word: Size of the block (24 bytes)
2nd word: Line number
3rd word: 0xFFFFFFFF
4th word: Index into the string table for the prefix
5th word: Index into the string table for the URI
endNameSpace blocks consist of 6 words
0th word: The endNameSpace tag (0x00100101)
1st word: Size of the block (24 bytes)
2nd word: Line number
3rd word: 0xFFFFFFFF
4th word: Index into the string table for the prefix
5th word: Index into the string table for the URI
*/
// Step through the XML tree element tags and attributes
var off = xmlTagOff
var indent = 0
while (off < xml.size) {
val tag0 = lew(xml, off)
val nameSi = lew(xml, off + 5 * 4)
when (tag0) {
startTag -> {
val numbAttrs = lew(xml, off + 7 * 4) // Number of Attributes to follow
off += 9 * 4 // Skip over 6+3 words of startTag data
val name = compXmlString(xml, sitOff, stOff, nameSi)
// Look for the Attributes
val sb = StringBuffer()
for (ii in 0 until numbAttrs) {
val attrNameSi = lew(xml, off + 1 * 4) // AttrName String Index
val attrValueSi = lew(xml, off + 2 * 4) // AttrValue Str Ind, or 0xFFFFFF
val attrResId = lew(xml, off + 4 * 4) // AttrValue ResourceId or dup AttrValue StrInd
off += 5 * 4 // Skip over the 5 words of an attribute
val attrName = compXmlString(xml, sitOff, stOff, attrNameSi)
val attrValue = if (attrValueSi != -1)
compXmlString(xml, sitOff, stOff, attrValueSi)
else
"resourceID 0x" + Integer.toHexString(attrResId)
sb.append(" $attrName=\"$attrValue\"")
}
resultXml.append(prtIndent(indent, "<$name$sb>"))
indent++
}
endTag -> {
indent--
off += 6 * 4 // Skip over 6 words of endTag data
val name = compXmlString(xml, sitOff, stOff, nameSi)
resultXml.append(prtIndent(indent, "</$name>")
)
}
textTag -> { // Text that is hanging out between start and end tags
val text = compXmlString(xml, sitOff, stOff, lew(xml, off + 16))
resultXml.append(text)
off += lew(xml, off + 4)
}
startNameSpace -> {
//Todo startNameSpace and endNameSpace are effectively skipped, but they are not handled.
off += lew(xml, off + 4)
}
endNameSpace -> {
off += lew(xml, off + 4)
}
else -> {
Log.d(
"Applog", " Unrecognized tag code '" + Integer.toHexString(tag0)
+ "' at offset " + off
)
}
}
}
return resultXml.toString()
}
/**
* Tool Method for decompressXML();
* Compute binary XML to its string format
* Source: Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689
*
* @param xml Binary-formatted XML
* @param sitOff
* @param stOff
* @param strInd
* @return String-formatted XML
*/
private fun compXmlString(
xml: ByteArray, @Suppress("SameParameterValue") sitOff: Int,
stOff: Int,
strInd: Int
): String? {
if (strInd < 0) return null
val strOff = stOff + lew(xml, sitOff + strInd * 4)
return compXmlStringAt(xml, strOff)
}
/**
* Tool Method for decompressXML();
* Apply indentation
*
* @param indent Indentation level
* @param str String to indent
* @return Indented string
*/
private fun prtIndent(indent: Int, str: String): String {
return spaces.substring(0, min(indent * 2, spaces.length)) + str
}
/**
* Tool method for decompressXML()
* 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.
*
* @param arr StringTable array
* @param strOff Offset to get string from
* @return String from StringTable at offset strOff
*/
private fun compXmlStringAt(arr: ByteArray, strOff: Int): String {
var start = strOff
var charSetUsed: Charset = Charsets.UTF_16LE
val byteLength = if (mIsUTF8) {
charSetUsed = Charsets.UTF_8
start += 2
arr[strOff + 1].toInt() and 0xFF
} else { // UTF-16LE
start += 2
((arr[strOff + 1].toInt() and 0xFF shl 8) or (arr[strOff].toInt() and 0xFF)) * 2
}
return String(arr, start, byteLength, charSetUsed)
}
/**
* Return value of a Little Endian 32 bit word from the byte array
* at offset off.
*
* @param arr Byte array with 32 bit word
* @param off Offset to get word from
* @return Value of Little Endian 32 bit word specified
*/
private fun lew(arr: ByteArray, off: Int): Int {
return (arr[off + 3] shl 24 and -0x1000000 or ((arr[off + 2] shl 16) and 0xff0000)
or (arr[off + 1] shl 8 and 0xff00) or (arr[off].toInt() and 0xFF))
}
private infix fun Byte.shl(i: Int): Int = (this.toInt() shl i)
}
这篇关于即使使用InputStream，如何获取APK文件的可靠且有效的清单内容?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！