StatiXOS
/
android_frameworks_base
forked from LeddaZ/frameworks_base
3
0
Fork 0
Code Pull Requests Activity
android_frameworks_base/tools/split-select/Main.cpp

377 lines
14 KiB
C++
Raw Blame History

/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <algorithm>
#include <cstdio>
#include "aapt/AaptUtil.h"
#include "Grouper.h"
#include "Rule.h"
#include "RuleGenerator.h"
#include "SplitDescription.h"
#include "SplitSelector.h"
#include <androidfw/AssetManager.h>
#include <androidfw/ResourceTypes.h>
#include <utils/KeyedVector.h>
#include <utils/Vector.h>
using namespace android;
namespace split {
static void usage() {
fprintf(stderr,
"split-select --help\n"
"split-select --target <config> --base <path/to/apk> [--split <path/to/apk> [...]]\n"
"split-select --generate --base <path/to/apk> [--split <path/to/apk> [...]]\n"
"\n"
" --help Displays more information about this program.\n"
" --target <config> Performs the Split APK selection on the given configuration.\n"
" --generate Generates the logic for selecting the Split APK, in JSON format.\n"
" --base <path/to/apk> Specifies the base APK, from which all Split APKs must be based off.\n"
" --split <path/to/apk> Includes a Split APK in the selection process.\n"
"\n"
" Where <config> is an extended AAPT resource qualifier of the form\n"
" 'resource-qualifiers:extended-qualifiers', where 'resource-qualifiers' is an AAPT resource\n"
" qualifier (ex: en-rUS-sw600dp-xhdpi), and 'extended-qualifiers' is an ordered list of one\n"
" qualifier (or none) from each category:\n"
" Architecture: armeabi, armeabi-v7a, arm64-v8a, x86, x86_64, mips\n");
}
static void help() {
usage();
fprintf(stderr, "\n"
" Generates the logic for selecting a Split APK given some target Android device configuration.\n"
" Using the flag --generate will emit a JSON encoded tree of rules that must be satisfied in order\n"
" to install the given Split APK. Using the flag --target along with the device configuration\n"
" will emit the set of Split APKs to install, following the same logic that would have been emitted\n"
" via JSON.\n");
}
Vector<SplitDescription> select(const SplitDescription& target, const Vector<SplitDescription>& splits) {
const SplitSelector selector(splits);
return selector.getBestSplits(target);
}
void generate(const KeyedVector<String8, Vector<SplitDescription> >& splits, const String8& base) {
Vector<SplitDescription> allSplits;
const size_t apkSplitCount = splits.size();
for (size_t i = 0; i < apkSplitCount; i++) {
allSplits.appendVector(splits[i]);
}
const SplitSelector selector(allSplits);
KeyedVector<SplitDescription, sp<Rule> > rules(selector.getRules());
bool first = true;
fprintf(stdout, "[\n");
for (size_t i = 0; i < apkSplitCount; i++) {
if (splits.keyAt(i) == base) {
// Skip the base.
continue;
}
if (!first) {
fprintf(stdout, ",\n");
}
first = false;
sp<Rule> masterRule = new Rule();
masterRule->op = Rule::OR_SUBRULES;
const Vector<SplitDescription>& splitDescriptions = splits[i];
const size_t splitDescriptionCount = splitDescriptions.size();
for (size_t j = 0; j < splitDescriptionCount; j++) {
masterRule->subrules.add(rules.valueFor(splitDescriptions[j]));
}
masterRule = Rule::simplify(masterRule);
fprintf(stdout, " {\n \"path\": \"%s\",\n \"rules\": %s\n }",
splits.keyAt(i).c_str(), masterRule->toJson(2).c_str());
}
fprintf(stdout, "\n]\n");
}
static void removeRuntimeQualifiers(ConfigDescription* outConfig) {
outConfig->imsi = 0;
outConfig->orientation = ResTable_config::ORIENTATION_ANY;
outConfig->screenWidth = ResTable_config::SCREENWIDTH_ANY;
outConfig->screenHeight = ResTable_config::SCREENHEIGHT_ANY;
outConfig->uiMode &= ResTable_config::UI_MODE_NIGHT_ANY;
}
struct AppInfo {
int versionCode;
int minSdkVersion;
bool multiArch;
};
static bool getAppInfo(const String8& path, AppInfo& outInfo) {
memset(&outInfo, 0, sizeof(outInfo));
AssetManager assetManager;
int32_t cookie = 0;
if (!assetManager.addAssetPath(path, &cookie)) {
return false;
}
Asset* asset = assetManager.openNonAsset(cookie, "AndroidManifest.xml", Asset::ACCESS_BUFFER);
if (asset == NULL) {
return false;
}
ResXMLTree xml;
if (xml.setTo(asset->getBuffer(true), asset->getLength(), false) != NO_ERROR) {
delete asset;
return false;
}
const String16 kAndroidNamespace("http://schemas.android.com/apk/res/android");
const String16 kManifestTag("manifest");
const String16 kApplicationTag("application");
const String16 kUsesSdkTag("uses-sdk");
const String16 kVersionCodeAttr("versionCode");
const String16 kMultiArchAttr("multiArch");
const String16 kMinSdkVersionAttr("minSdkVersion");
ResXMLParser::event_code_t event;
while ((event = xml.next()) != ResXMLParser::BAD_DOCUMENT &&
event != ResXMLParser::END_DOCUMENT) {
if (event != ResXMLParser::START_TAG) {
continue;
}
size_t len;
const char16_t* name = xml.getElementName(&len);
String16 name16(name, len);
if (name16 == kManifestTag) {
ssize_t idx = xml.indexOfAttribute(kAndroidNamespace.c_str(), kAndroidNamespace.size(),
kVersionCodeAttr.c_str(), kVersionCodeAttr.size());
if (idx >= 0) {
outInfo.versionCode = xml.getAttributeData(idx);
}
} else if (name16 == kApplicationTag) {
ssize_t idx = xml.indexOfAttribute(kAndroidNamespace.c_str(), kAndroidNamespace.size(),
kMultiArchAttr.c_str(), kMultiArchAttr.size());
if (idx >= 0) {
outInfo.multiArch = xml.getAttributeData(idx) != 0;
}
} else if (name16 == kUsesSdkTag) {
ssize_t idx =
xml.indexOfAttribute(kAndroidNamespace.c_str(), kAndroidNamespace.size(),
kMinSdkVersionAttr.c_str(), kMinSdkVersionAttr.size());
if (idx >= 0) {
uint16_t type = xml.getAttributeDataType(idx);
if (type >= Res_value::TYPE_FIRST_INT && type <= Res_value::TYPE_LAST_INT) {
outInfo.minSdkVersion = xml.getAttributeData(idx);
} else if (type == Res_value::TYPE_STRING) {
auto minSdk8 = xml.getStrings().string8ObjectAt(idx);
if (!minSdk8.has_value()) {
fprintf(stderr, "warning: failed to retrieve android:minSdkVersion.\n");
} else {
char *endPtr;
int minSdk = strtol(minSdk8->c_str(), &endPtr, 10);
if (endPtr != minSdk8->c_str() + minSdk8->size()) {
fprintf(stderr, "warning: failed to parse android:minSdkVersion '%s'\n",
minSdk8->c_str());
} else {
outInfo.minSdkVersion = minSdk;
}
}
} else {
fprintf(stderr, "warning: unrecognized value for android:minSdkVersion.\n");
}
}
}
}
delete asset;
return true;
}
static Vector<SplitDescription> extractSplitDescriptionsFromApk(const String8& path) {
AssetManager assetManager;
Vector<SplitDescription> splits;
int32_t cookie = 0;
if (!assetManager.addAssetPath(path, &cookie)) {
return splits;
}
const ResTable& res = assetManager.getResources(false);
if (res.getError() == NO_ERROR) {
Vector<ResTable_config> configs;
res.getConfigurations(&configs, true);
const size_t configCount = configs.size();
for (size_t i = 0; i < configCount; i++) {
splits.add();
splits.editTop().config = configs[i];
}
}
AssetDir* dir = assetManager.openNonAssetDir(cookie, "lib");
if (dir != NULL) {
const size_t fileCount = dir->getFileCount();
for (size_t i = 0; i < fileCount; i++) {
splits.add();
Vector<String8> parts = AaptUtil::splitAndLowerCase(dir->getFileName(i), '-');
if (parseAbi(parts, 0, &splits.editTop()) < 0) {
fprintf(stderr, "Malformed library %s\n", dir->getFileName(i).c_str());
splits.pop();
}
}
delete dir;
}
return splits;
}
static int main(int argc, char** argv) {
// Skip over the first argument.
argc--;
argv++;
bool generateFlag = false;
String8 targetConfigStr;
Vector<String8> splitApkPaths;
String8 baseApkPath;
while (argc > 0) {
const String8 arg(*argv);
if (arg == "--target") {
argc--;
argv++;
if (argc < 1) {
fprintf(stderr, "error: missing parameter for --target.\n");
usage();
return 1;
}
targetConfigStr = *argv;
} else if (arg == "--split") {
argc--;
argv++;
if (argc < 1) {
fprintf(stderr, "error: missing parameter for --split.\n");
usage();
return 1;
}
splitApkPaths.add(String8(*argv));
} else if (arg == "--base") {
argc--;
argv++;
if (argc < 1) {
fprintf(stderr, "error: missing parameter for --base.\n");
usage();
return 1;
}
if (baseApkPath.size() > 0) {
fprintf(stderr, "error: multiple --base flags not allowed.\n");
usage();
return 1;
}
baseApkPath = *argv;
} else if (arg == "--generate") {
generateFlag = true;
} else if (arg == "--help") {
help();
return 0;
} else {
fprintf(stderr, "error: unknown argument '%s'.\n", arg.c_str());
usage();
return 1;
}
argc--;
argv++;
}
if (!generateFlag && targetConfigStr == "") {
usage();
return 1;
}
if (baseApkPath.size() == 0) {
fprintf(stderr, "error: missing --base argument.\n");
usage();
return 1;
}
// Find out some details about the base APK.
AppInfo baseAppInfo;
if (!getAppInfo(baseApkPath, baseAppInfo)) {
fprintf(stderr, "error: unable to read base APK: '%s'.\n", baseApkPath.c_str());
return 1;
}
SplitDescription targetSplit;
if (!generateFlag) {
if (!SplitDescription::parse(targetConfigStr, &targetSplit)) {
fprintf(stderr, "error: invalid --target config: '%s'.\n", targetConfigStr.c_str());
usage();
return 1;
}
// We don't want to match on things that will change at run-time
// (orientation, w/h, etc.).
removeRuntimeQualifiers(&targetSplit.config);
}
splitApkPaths.add(baseApkPath);
KeyedVector<String8, Vector<SplitDescription> > apkPathSplitMap;
KeyedVector<SplitDescription, String8> splitApkPathMap;
Vector<SplitDescription> splitConfigs;
const size_t splitCount = splitApkPaths.size();
for (size_t i = 0; i < splitCount; i++) {
Vector<SplitDescription> splits = extractSplitDescriptionsFromApk(splitApkPaths[i]);
if (splits.isEmpty()) {
fprintf(stderr, "error: invalid --split path: '%s'. No splits found.\n",
splitApkPaths[i].c_str());
usage();
return 1;
}
apkPathSplitMap.replaceValueFor(splitApkPaths[i], splits);
const size_t apkSplitDescriptionCount = splits.size();
for (size_t j = 0; j < apkSplitDescriptionCount; j++) {
splitApkPathMap.replaceValueFor(splits[j], splitApkPaths[i]);
}
splitConfigs.appendVector(splits);
}
if (!generateFlag) {
Vector<SplitDescription> matchingConfigs = select(targetSplit, splitConfigs);
const size_t matchingConfigCount = matchingConfigs.size();
SortedVector<String8> matchingSplitPaths;
for (size_t i = 0; i < matchingConfigCount; i++) {
matchingSplitPaths.add(splitApkPathMap.valueFor(matchingConfigs[i]));
}
const size_t matchingSplitApkPathCount = matchingSplitPaths.size();
for (size_t i = 0; i < matchingSplitApkPathCount; i++) {
if (matchingSplitPaths[i] != baseApkPath) {
fprintf(stdout, "%s\n", matchingSplitPaths[i].c_str());
}
}
} else {
generate(apkPathSplitMap, baseApkPath);
}
return 0;
}
} // namespace split
int main(int argc, char** argv) {
return split::main(argc, argv);
}
View Git Blame Copy Permalink