c3dc0b57b8
It was complicated to get the tool building on Windows, Linux, and OSX with C++11 support. OSX uses Clang to build C++11 binaries, which requires the libc++ standard library. Since most of the dependencies of this program are built against libstdc++, this was difficult to resolve. Now we build without C++11 support. Change-Id: I4e537c113734508a8f480a1c402ed237de4f0e60
318 lines
11 KiB
C++
318 lines
11 KiB
C++
/*
|
|
* 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 <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> --split <path/to/apk> [--split <path/to/apk> [...]]\n"
|
|
"split-select --generate --split <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"
|
|
" --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");
|
|
}
|
|
|
|
class SplitSelector {
|
|
public:
|
|
SplitSelector();
|
|
SplitSelector(const Vector<SplitDescription>& splits);
|
|
|
|
Vector<SplitDescription> getBestSplits(const SplitDescription& target) const;
|
|
|
|
template <typename RuleGenerator>
|
|
KeyedVector<SplitDescription, sp<Rule> > getRules() const;
|
|
|
|
private:
|
|
Vector<SortedVector<SplitDescription> > mGroups;
|
|
};
|
|
|
|
SplitSelector::SplitSelector() {
|
|
}
|
|
|
|
SplitSelector::SplitSelector(const Vector<SplitDescription>& splits)
|
|
: mGroups(groupByMutualExclusivity(splits)) {
|
|
}
|
|
|
|
static void selectBestFromGroup(const SortedVector<SplitDescription>& splits,
|
|
const SplitDescription& target, Vector<SplitDescription>& splitsOut) {
|
|
SplitDescription bestSplit;
|
|
bool isSet = false;
|
|
const size_t splitCount = splits.size();
|
|
for (size_t j = 0; j < splitCount; j++) {
|
|
const SplitDescription& thisSplit = splits[j];
|
|
if (!thisSplit.match(target)) {
|
|
continue;
|
|
}
|
|
|
|
if (!isSet || thisSplit.isBetterThan(bestSplit, target)) {
|
|
isSet = true;
|
|
bestSplit = thisSplit;
|
|
}
|
|
}
|
|
|
|
if (isSet) {
|
|
splitsOut.add(bestSplit);
|
|
}
|
|
}
|
|
|
|
Vector<SplitDescription> SplitSelector::getBestSplits(const SplitDescription& target) const {
|
|
Vector<SplitDescription> bestSplits;
|
|
const size_t groupCount = mGroups.size();
|
|
for (size_t i = 0; i < groupCount; i++) {
|
|
selectBestFromGroup(mGroups[i], target, bestSplits);
|
|
}
|
|
return bestSplits;
|
|
}
|
|
|
|
template <typename RuleGenerator>
|
|
KeyedVector<SplitDescription, sp<Rule> > SplitSelector::getRules() const {
|
|
KeyedVector<SplitDescription, sp<Rule> > rules;
|
|
|
|
const size_t groupCount = mGroups.size();
|
|
for (size_t i = 0; i < groupCount; i++) {
|
|
const SortedVector<SplitDescription>& splits = mGroups[i];
|
|
const size_t splitCount = splits.size();
|
|
for (size_t j = 0; j < splitCount; j++) {
|
|
sp<Rule> rule = Rule::simplify(RuleGenerator::generate(splits, j));
|
|
if (rule != NULL) {
|
|
rules.add(splits[j], rule);
|
|
}
|
|
}
|
|
}
|
|
return rules;
|
|
}
|
|
|
|
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) {
|
|
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<RuleGenerator>());
|
|
|
|
fprintf(stdout, "[\n");
|
|
for (size_t i = 0; i < apkSplitCount; i++) {
|
|
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 }%s\n",
|
|
splits.keyAt(i).string(),
|
|
masterRule->toJson(2).string(),
|
|
i < apkSplitCount - 1 ? "," : "");
|
|
}
|
|
fprintf(stdout, "]\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;
|
|
}
|
|
|
|
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);
|
|
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).string());
|
|
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;
|
|
while (argc > 0) {
|
|
const String8 arg(*argv);
|
|
if (arg == "--target") {
|
|
argc--;
|
|
argv++;
|
|
if (argc < 1) {
|
|
fprintf(stderr, "Missing parameter for --split.\n");
|
|
usage();
|
|
return 1;
|
|
}
|
|
targetConfigStr.setTo(*argv);
|
|
} else if (arg == "--split") {
|
|
argc--;
|
|
argv++;
|
|
if (argc < 1) {
|
|
fprintf(stderr, "Missing parameter for --split.\n");
|
|
usage();
|
|
return 1;
|
|
}
|
|
splitApkPaths.add(String8(*argv));
|
|
} else if (arg == "--generate") {
|
|
generateFlag = true;
|
|
} else if (arg == "--help") {
|
|
help();
|
|
return 0;
|
|
} else {
|
|
fprintf(stderr, "Unknown argument '%s'\n", arg.string());
|
|
usage();
|
|
return 1;
|
|
}
|
|
argc--;
|
|
argv++;
|
|
}
|
|
|
|
if (!generateFlag && targetConfigStr == "") {
|
|
usage();
|
|
return 1;
|
|
}
|
|
|
|
if (splitApkPaths.size() == 0) {
|
|
usage();
|
|
return 1;
|
|
}
|
|
|
|
SplitDescription targetSplit;
|
|
if (!generateFlag) {
|
|
if (!SplitDescription::parse(targetConfigStr, &targetSplit)) {
|
|
fprintf(stderr, "Invalid --target config: '%s'\n",
|
|
targetConfigStr.string());
|
|
usage();
|
|
return 1;
|
|
}
|
|
|
|
// We don't want to match on things that will change at run-time
|
|
// (orientation, w/h, etc.).
|
|
removeRuntimeQualifiers(&targetSplit.config);
|
|
}
|
|
|
|
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, "Invalid --split path: '%s'. No splits found.\n",
|
|
splitApkPaths[i].string());
|
|
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++) {
|
|
fprintf(stderr, "%s\n", matchingSplitPaths[i].string());
|
|
}
|
|
} else {
|
|
generate(apkPathSplitMap);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
} // namespace split
|
|
|
|
int main(int argc, char** argv) {
|
|
return split::main(argc, argv);
|
|
}
|