Я пытаюсь получить значения minSdkVersion и targetSdkVersion из apk, хранящегося на устройстве. Здесь обсуждаются другие подробности , но только targetSdkVersion
доступен в классе ApplicationInfo. Можно ли получить minSdkVersion, кроме как извлечение файла apk и чтение AndroidManifest.xml?
Получите minSdkVersion и targetSdkVersion из файла apk
Ответ 1
Я не считаю, что это возможно сделать самостоятельно, и для этого нет готового api. Существующие методы, которые читают и анализируют AndroidManifest, вообще не учитывают minSdkVersion.
Чтобы проверить файл apk, не используя готовые функции, вам нужно вручную добавить его в диспетчер активов. И этот метод отмечен как "Не для использования приложениями", который, как мне кажется, обычно означает, что не рекомендуется называть его из приложения.
Если вам удастся позвонить:
public final int addAssetPath(String path) {
Из вашего приложения вы сможете получить minSdkVersion, проанализировав XML файл, рассмотрите этот код:
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]);
}
}
Где вы сможете проанализировать файл AndroidManifest с помощью XmlResourceParser и найти элемент для 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 для своего приложения. Из быстрого просмотра кода на С++ кажется, что он не добавляется ни в один глобальный список.
код: http://androidxref.com/5.1.1_r6/xref/frameworks/base/libs/androidfw/AssetManager.cpp#173
Ответ 2
Использовать aapt:
aapt list -a 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:
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.
Шаг 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:
Это не какой-либо шаг, просто скопируйте содержимое обеих папок (в данном случае и новую папку) на один
и наслаждайтесь исходным кодом...
Ответ 3
Скопируйте 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 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. Я получил эти методы отсюда:
Как получить программный файл .apk приложения программно
И здесь:
Как проанализировать файл AndroidManifest.xml внутри пакета .apk
Ответ 4
Это можно сделать легко. Вы должны следовать
- Apk Extractor или введите команду adb pull/data/app/package_name.apk
- Apk Tool jar file
Теперь введите команду
apktool d package_name.apk
apk будет извлечен в текущий каталог, и у вас будет доступный для чтения файл AndroidManfiest
Ответ 5
Для Android API 24 (Android N - 7.0) и выше у вас действительно есть:
https://developer.android.com/reference/android/content/pm/ApplicationInfo.html#minSdkVersion
Для более ранних версий вы можете использовать обходной путь, поскольку я написал здесь, или библиотеку для этого. Например:
https://github.com/jaredrummler/APKParser
Обратите внимание, что эта библиотека может занять много памяти и времени кучи, поэтому для ее оптимизации необходимы некоторые изменения, так как я предложил здесь.
Ответ 6
Если вам нужен только minSdkVersion и targetSdkVersion, а также множество других деталей с загруженным файлом apk. Все, что вам нужно - это инструменты aapt, и вы можете запустить команду ниже в терминале.
aapt dump badging yourapk.apk
Вы можете grep для sdkVersion для minSdk
aapt dump badging yourapk.apk | grep sdkVersion