355f285ffd
When a preferred density is supplied, the closest matching densities will be selected, the rest stripped from the APK. Split support will be enabled in a later CL. Command line support is still needed, but the foundation is ready. Bug:25958912 Change-Id: I56d599806b4ec4ffa24e17aad48d47130ca05c08
1260 lines
49 KiB
C++
1260 lines
49 KiB
C++
/*
|
|
* Copyright (C) 2015 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 "AppInfo.h"
|
|
#include "Debug.h"
|
|
#include "Flags.h"
|
|
#include "Locale.h"
|
|
#include "NameMangler.h"
|
|
#include "ResourceUtils.h"
|
|
#include "compile/IdAssigner.h"
|
|
#include "filter/ConfigFilter.h"
|
|
#include "flatten/Archive.h"
|
|
#include "flatten/TableFlattener.h"
|
|
#include "flatten/XmlFlattener.h"
|
|
#include "io/FileSystem.h"
|
|
#include "io/ZipArchive.h"
|
|
#include "java/JavaClassGenerator.h"
|
|
#include "java/ManifestClassGenerator.h"
|
|
#include "java/ProguardRules.h"
|
|
#include "link/Linkers.h"
|
|
#include "link/ProductFilter.h"
|
|
#include "link/ReferenceLinker.h"
|
|
#include "link/ManifestFixer.h"
|
|
#include "link/TableMerger.h"
|
|
#include "process/IResourceTableConsumer.h"
|
|
#include "process/SymbolTable.h"
|
|
#include "proto/ProtoSerialize.h"
|
|
#include "split/TableSplitter.h"
|
|
#include "unflatten/BinaryResourceParser.h"
|
|
#include "util/Files.h"
|
|
#include "util/StringPiece.h"
|
|
#include "xml/XmlDom.h"
|
|
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
|
|
#include <fstream>
|
|
#include <sys/stat.h>
|
|
#include <vector>
|
|
|
|
namespace aapt {
|
|
|
|
struct LinkOptions {
|
|
std::string outputPath;
|
|
std::string manifestPath;
|
|
std::vector<std::string> includePaths;
|
|
std::vector<std::string> overlayFiles;
|
|
Maybe<std::string> generateJavaClassPath;
|
|
Maybe<std::u16string> customJavaPackage;
|
|
std::set<std::u16string> extraJavaPackages;
|
|
Maybe<std::string> generateProguardRulesPath;
|
|
bool noAutoVersion = false;
|
|
bool staticLib = false;
|
|
bool generateNonFinalIds = false;
|
|
bool outputToDirectory = false;
|
|
bool autoAddOverlay = false;
|
|
bool doNotCompressAnything = false;
|
|
std::vector<std::string> extensionsToNotCompress;
|
|
Maybe<std::u16string> privateSymbols;
|
|
ManifestFixerOptions manifestFixerOptions;
|
|
std::unordered_set<std::string> products;
|
|
TableSplitterOptions tableSplitterOptions;
|
|
};
|
|
|
|
struct LinkContext : public IAaptContext {
|
|
StdErrDiagnostics mDiagnostics;
|
|
std::unique_ptr<NameMangler> mNameMangler;
|
|
std::u16string mCompilationPackage;
|
|
uint8_t mPackageId;
|
|
std::unique_ptr<ISymbolTable> mSymbols;
|
|
bool mVerbose = false;
|
|
|
|
IDiagnostics* getDiagnostics() override {
|
|
return &mDiagnostics;
|
|
}
|
|
|
|
NameMangler* getNameMangler() override {
|
|
return mNameMangler.get();
|
|
}
|
|
|
|
StringPiece16 getCompilationPackage() override {
|
|
return mCompilationPackage;
|
|
}
|
|
|
|
uint8_t getPackageId() override {
|
|
return mPackageId;
|
|
}
|
|
|
|
ISymbolTable* getExternalSymbols() override {
|
|
return mSymbols.get();
|
|
}
|
|
|
|
bool verbose() override {
|
|
return mVerbose;
|
|
}
|
|
};
|
|
|
|
static bool copyFileToArchive(io::IFile* file, const std::string& outPath,
|
|
uint32_t compressionFlags,
|
|
IArchiveWriter* writer, IAaptContext* context) {
|
|
std::unique_ptr<io::IData> data = file->openAsData();
|
|
if (!data) {
|
|
context->getDiagnostics()->error(DiagMessage(file->getSource())
|
|
<< "failed to open file");
|
|
return false;
|
|
}
|
|
|
|
CompiledFileInputStream inputStream(data->data(), data->size());
|
|
if (!inputStream.CompiledFile()) {
|
|
context->getDiagnostics()->error(DiagMessage(file->getSource())
|
|
<< "invalid compiled file header");
|
|
return false;
|
|
}
|
|
|
|
if (context->verbose()) {
|
|
context->getDiagnostics()->note(DiagMessage() << "writing " << outPath << " to archive");
|
|
}
|
|
|
|
if (writer->startEntry(outPath, compressionFlags)) {
|
|
if (writer->writeEntry(reinterpret_cast<const uint8_t*>(inputStream.data()),
|
|
inputStream.size())) {
|
|
if (writer->finishEntry()) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
context->getDiagnostics()->error(DiagMessage() << "failed to write file " << outPath);
|
|
return false;
|
|
}
|
|
|
|
static bool flattenXml(xml::XmlResource* xmlRes, const StringPiece& path, Maybe<size_t> maxSdkLevel,
|
|
bool keepRawValues, IArchiveWriter* writer, IAaptContext* context) {
|
|
BigBuffer buffer(1024);
|
|
XmlFlattenerOptions options = {};
|
|
options.keepRawValues = keepRawValues;
|
|
options.maxSdkLevel = maxSdkLevel;
|
|
XmlFlattener flattener(&buffer, options);
|
|
if (!flattener.consume(context, xmlRes)) {
|
|
return false;
|
|
}
|
|
|
|
if (context->verbose()) {
|
|
DiagMessage msg;
|
|
msg << "writing " << path << " to archive";
|
|
if (maxSdkLevel) {
|
|
msg << " maxSdkLevel=" << maxSdkLevel.value();
|
|
}
|
|
context->getDiagnostics()->note(msg);
|
|
}
|
|
|
|
if (writer->startEntry(path, ArchiveEntry::kCompress)) {
|
|
if (writer->writeEntry(buffer)) {
|
|
if (writer->finishEntry()) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
context->getDiagnostics()->error(DiagMessage() << "failed to write " << path << " to archive");
|
|
return false;
|
|
}
|
|
|
|
/*static std::unique_ptr<ResourceTable> loadTable(const Source& source, const void* data, size_t len,
|
|
IDiagnostics* diag) {
|
|
std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>();
|
|
BinaryResourceParser parser(diag, table.get(), source, data, len);
|
|
if (!parser.parse()) {
|
|
return {};
|
|
}
|
|
return table;
|
|
}*/
|
|
|
|
static std::unique_ptr<ResourceTable> loadTableFromPb(const Source& source,
|
|
const void* data, size_t len,
|
|
IDiagnostics* diag) {
|
|
pb::ResourceTable pbTable;
|
|
if (!pbTable.ParseFromArray(data, len)) {
|
|
diag->error(DiagMessage(source) << "invalid compiled table");
|
|
return {};
|
|
}
|
|
|
|
std::unique_ptr<ResourceTable> table = deserializeTableFromPb(pbTable, source, diag);
|
|
if (!table) {
|
|
return {};
|
|
}
|
|
return table;
|
|
}
|
|
|
|
/**
|
|
* Inflates an XML file from the source path.
|
|
*/
|
|
static std::unique_ptr<xml::XmlResource> loadXml(const std::string& path, IDiagnostics* diag) {
|
|
std::ifstream fin(path, std::ifstream::binary);
|
|
if (!fin) {
|
|
diag->error(DiagMessage(path) << strerror(errno));
|
|
return {};
|
|
}
|
|
return xml::inflate(&fin, diag, Source(path));
|
|
}
|
|
|
|
static std::unique_ptr<xml::XmlResource> loadBinaryXmlSkipFileExport(const Source& source,
|
|
const void* data, size_t len,
|
|
IDiagnostics* diag) {
|
|
CompiledFileInputStream inputStream(data, len);
|
|
if (!inputStream.CompiledFile()) {
|
|
diag->error(DiagMessage(source) << "invalid compiled file header");
|
|
return {};
|
|
}
|
|
|
|
const uint8_t* xmlData = reinterpret_cast<const uint8_t*>(inputStream.data());
|
|
const size_t xmlDataLen = inputStream.size();
|
|
|
|
std::unique_ptr<xml::XmlResource> xmlRes = xml::inflate(xmlData, xmlDataLen, diag, source);
|
|
if (!xmlRes) {
|
|
return {};
|
|
}
|
|
return xmlRes;
|
|
}
|
|
|
|
static std::unique_ptr<ResourceFile> loadFileExportHeader(const Source& source,
|
|
const void* data, size_t len,
|
|
IDiagnostics* diag) {
|
|
CompiledFileInputStream inputStream(data, len);
|
|
const pb::CompiledFile* pbFile = inputStream.CompiledFile();
|
|
if (!pbFile) {
|
|
diag->error(DiagMessage(source) << "invalid compiled file header");
|
|
return {};
|
|
}
|
|
|
|
std::unique_ptr<ResourceFile> resFile = deserializeCompiledFileFromPb(*pbFile, source, diag);
|
|
if (!resFile) {
|
|
return {};
|
|
}
|
|
return resFile;
|
|
}
|
|
|
|
struct ResourceFileFlattenerOptions {
|
|
bool noAutoVersion = false;
|
|
bool keepRawValues = false;
|
|
bool doNotCompressAnything = false;
|
|
std::vector<std::string> extensionsToNotCompress;
|
|
};
|
|
|
|
class ResourceFileFlattener {
|
|
public:
|
|
ResourceFileFlattener(const ResourceFileFlattenerOptions& options,
|
|
IAaptContext* context, proguard::KeepSet* keepSet) :
|
|
mOptions(options), mContext(context), mKeepSet(keepSet) {
|
|
}
|
|
|
|
bool flatten(ResourceTable* table, IArchiveWriter* archiveWriter);
|
|
|
|
private:
|
|
struct FileOperation {
|
|
io::IFile* fileToCopy;
|
|
std::unique_ptr<xml::XmlResource> xmlToFlatten;
|
|
std::string dstPath;
|
|
};
|
|
|
|
uint32_t getCompressionFlags(const StringPiece& str);
|
|
|
|
std::unique_ptr<xml::XmlResource> linkAndVersionXmlFile(const ResourceEntry* entry,
|
|
const ResourceFile& fileDesc,
|
|
io::IFile* file,
|
|
ResourceTable* table);
|
|
|
|
ResourceFileFlattenerOptions mOptions;
|
|
IAaptContext* mContext;
|
|
proguard::KeepSet* mKeepSet;
|
|
};
|
|
|
|
uint32_t ResourceFileFlattener::getCompressionFlags(const StringPiece& str) {
|
|
if (mOptions.doNotCompressAnything) {
|
|
return 0;
|
|
}
|
|
|
|
for (const std::string& extension : mOptions.extensionsToNotCompress) {
|
|
if (util::stringEndsWith<char>(str, extension)) {
|
|
return 0;
|
|
}
|
|
}
|
|
return ArchiveEntry::kCompress;
|
|
}
|
|
|
|
std::unique_ptr<xml::XmlResource> ResourceFileFlattener::linkAndVersionXmlFile(
|
|
const ResourceEntry* entry,
|
|
const ResourceFile& fileDesc,
|
|
io::IFile* file,
|
|
ResourceTable* table) {
|
|
const StringPiece srcPath = file->getSource().path;
|
|
if (mContext->verbose()) {
|
|
mContext->getDiagnostics()->note(DiagMessage() << "linking " << srcPath);
|
|
}
|
|
|
|
std::unique_ptr<io::IData> data = file->openAsData();
|
|
if (!data) {
|
|
mContext->getDiagnostics()->error(DiagMessage(file->getSource()) << "failed to open file");
|
|
return {};
|
|
}
|
|
|
|
std::unique_ptr<xml::XmlResource> xmlRes;
|
|
if (util::stringEndsWith<char>(srcPath, ".flat")) {
|
|
xmlRes = loadBinaryXmlSkipFileExport(file->getSource(), data->data(), data->size(),
|
|
mContext->getDiagnostics());
|
|
} else {
|
|
xmlRes = xml::inflate(data->data(), data->size(), mContext->getDiagnostics(),
|
|
file->getSource());
|
|
}
|
|
|
|
if (!xmlRes) {
|
|
return {};
|
|
}
|
|
|
|
// Copy the the file description header.
|
|
xmlRes->file = fileDesc;
|
|
|
|
XmlReferenceLinker xmlLinker;
|
|
if (!xmlLinker.consume(mContext, xmlRes.get())) {
|
|
return {};
|
|
}
|
|
|
|
if (!proguard::collectProguardRules(xmlRes->file.source, xmlRes.get(), mKeepSet)) {
|
|
return {};
|
|
}
|
|
|
|
if (!mOptions.noAutoVersion) {
|
|
// Find the first SDK level used that is higher than this defined config and
|
|
// not superseded by a lower or equal SDK level resource.
|
|
for (int sdkLevel : xmlLinker.getSdkLevels()) {
|
|
if (sdkLevel > xmlRes->file.config.sdkVersion) {
|
|
if (!shouldGenerateVersionedResource(entry, xmlRes->file.config, sdkLevel)) {
|
|
// If we shouldn't generate a versioned resource, stop checking.
|
|
break;
|
|
}
|
|
|
|
ResourceFile versionedFileDesc = xmlRes->file;
|
|
versionedFileDesc.config.sdkVersion = sdkLevel;
|
|
|
|
if (mContext->verbose()) {
|
|
mContext->getDiagnostics()->note(DiagMessage(versionedFileDesc.source)
|
|
<< "auto-versioning resource from config '"
|
|
<< xmlRes->file.config << "' -> '"
|
|
<< versionedFileDesc.config << "'");
|
|
}
|
|
|
|
std::u16string genPath = util::utf8ToUtf16(ResourceUtils::buildResourceFileName(
|
|
versionedFileDesc, mContext->getNameMangler()));
|
|
|
|
bool added = table->addFileReferenceAllowMangled(versionedFileDesc.name,
|
|
versionedFileDesc.config,
|
|
versionedFileDesc.source,
|
|
genPath,
|
|
file,
|
|
mContext->getDiagnostics());
|
|
if (!added) {
|
|
return {};
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return xmlRes;
|
|
}
|
|
|
|
/**
|
|
* Do not insert or remove any resources while executing in this function. It will
|
|
* corrupt the iteration order.
|
|
*/
|
|
bool ResourceFileFlattener::flatten(ResourceTable* table, IArchiveWriter* archiveWriter) {
|
|
bool error = false;
|
|
std::map<std::pair<ConfigDescription, StringPiece16>, FileOperation> configSortedFiles;
|
|
|
|
for (auto& pkg : table->packages) {
|
|
for (auto& type : pkg->types) {
|
|
// Sort by config and name, so that we get better locality in the zip file.
|
|
configSortedFiles.clear();
|
|
for (auto& entry : type->entries) {
|
|
// Iterate via indices because auto generated values can be inserted ahead of
|
|
// the value being processed.
|
|
for (size_t i = 0; i < entry->values.size(); i++) {
|
|
ResourceConfigValue* configValue = entry->values[i].get();
|
|
|
|
FileReference* fileRef = valueCast<FileReference>(configValue->value.get());
|
|
if (!fileRef) {
|
|
continue;
|
|
}
|
|
|
|
io::IFile* file = fileRef->file;
|
|
if (!file) {
|
|
mContext->getDiagnostics()->error(DiagMessage(fileRef->getSource())
|
|
<< "file not found");
|
|
return false;
|
|
}
|
|
|
|
FileOperation fileOp;
|
|
fileOp.dstPath = util::utf16ToUtf8(*fileRef->path);
|
|
|
|
const StringPiece srcPath = file->getSource().path;
|
|
if (type->type != ResourceType::kRaw &&
|
|
(util::stringEndsWith<char>(srcPath, ".xml.flat") ||
|
|
util::stringEndsWith<char>(srcPath, ".xml"))) {
|
|
ResourceFile fileDesc;
|
|
fileDesc.config = configValue->config;
|
|
fileDesc.name = ResourceName(pkg->name, type->type, entry->name);
|
|
fileDesc.source = fileRef->getSource();
|
|
fileOp.xmlToFlatten = linkAndVersionXmlFile(entry.get(), fileDesc,
|
|
file, table);
|
|
if (!fileOp.xmlToFlatten) {
|
|
error = true;
|
|
continue;
|
|
}
|
|
|
|
} else {
|
|
fileOp.fileToCopy = file;
|
|
}
|
|
|
|
// NOTE(adamlesinski): Explicitly construct a StringPiece16 here, or else
|
|
// we end up copying the string in the std::make_pair() method, then creating
|
|
// a StringPiece16 from the copy, which would cause us to end up referencing
|
|
// garbage in the map.
|
|
const StringPiece16 entryName(entry->name);
|
|
configSortedFiles[std::make_pair(configValue->config, entryName)] =
|
|
std::move(fileOp);
|
|
}
|
|
}
|
|
|
|
if (error) {
|
|
return false;
|
|
}
|
|
|
|
// Now flatten the sorted values.
|
|
for (auto& mapEntry : configSortedFiles) {
|
|
const ConfigDescription& config = mapEntry.first.first;
|
|
const FileOperation& fileOp = mapEntry.second;
|
|
|
|
if (fileOp.xmlToFlatten) {
|
|
Maybe<size_t> maxSdkLevel;
|
|
if (!mOptions.noAutoVersion) {
|
|
maxSdkLevel = std::max<size_t>(config.sdkVersion, 1u);
|
|
}
|
|
|
|
bool result = flattenXml(fileOp.xmlToFlatten.get(), fileOp.dstPath, maxSdkLevel,
|
|
mOptions.keepRawValues,
|
|
archiveWriter, mContext);
|
|
if (!result) {
|
|
error = true;
|
|
}
|
|
} else {
|
|
bool result = copyFileToArchive(fileOp.fileToCopy, fileOp.dstPath,
|
|
getCompressionFlags(fileOp.dstPath),
|
|
archiveWriter, mContext);
|
|
if (!result) {
|
|
error = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return !error;
|
|
}
|
|
|
|
class LinkCommand {
|
|
public:
|
|
LinkCommand(LinkContext* context, const LinkOptions& options) :
|
|
mOptions(options), mContext(context), mFinalTable(), mFileCollection(nullptr) {
|
|
std::unique_ptr<io::FileCollection> fileCollection =
|
|
util::make_unique<io::FileCollection>();
|
|
|
|
// Get a pointer to the FileCollection for convenience, but it will be owned by the vector.
|
|
mFileCollection = fileCollection.get();
|
|
|
|
// Move it to the collection.
|
|
mCollections.push_back(std::move(fileCollection));
|
|
}
|
|
|
|
/**
|
|
* Creates a SymbolTable that loads symbols from the various APKs and caches the
|
|
* results for faster lookup.
|
|
*/
|
|
std::unique_ptr<ISymbolTable> createSymbolTableFromIncludePaths() {
|
|
AssetManagerSymbolTableBuilder builder;
|
|
for (const std::string& path : mOptions.includePaths) {
|
|
if (mContext->verbose()) {
|
|
mContext->getDiagnostics()->note(DiagMessage(path) << "loading include path");
|
|
}
|
|
|
|
std::unique_ptr<android::AssetManager> assetManager =
|
|
util::make_unique<android::AssetManager>();
|
|
int32_t cookie = 0;
|
|
if (!assetManager->addAssetPath(android::String8(path.data(), path.size()), &cookie)) {
|
|
mContext->getDiagnostics()->error(
|
|
DiagMessage(path) << "failed to load include path");
|
|
return {};
|
|
}
|
|
builder.add(std::move(assetManager));
|
|
}
|
|
return builder.build();
|
|
}
|
|
|
|
Maybe<AppInfo> extractAppInfoFromManifest(xml::XmlResource* xmlRes) {
|
|
// Make sure the first element is <manifest> with package attribute.
|
|
if (xml::Element* manifestEl = xml::findRootElement(xmlRes->root.get())) {
|
|
if (manifestEl->namespaceUri.empty() && manifestEl->name == u"manifest") {
|
|
if (xml::Attribute* packageAttr = manifestEl->findAttribute({}, u"package")) {
|
|
return AppInfo{ packageAttr->value };
|
|
}
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
|
|
/**
|
|
* Precondition: ResourceTable doesn't have any IDs assigned yet, nor is it linked.
|
|
* Postcondition: ResourceTable has only one package left. All others are stripped, or there
|
|
* is an error and false is returned.
|
|
*/
|
|
bool verifyNoExternalPackages() {
|
|
auto isExtPackageFunc = [&](const std::unique_ptr<ResourceTablePackage>& pkg) -> bool {
|
|
return mContext->getCompilationPackage() != pkg->name ||
|
|
!pkg->id ||
|
|
pkg->id.value() != mContext->getPackageId();
|
|
};
|
|
|
|
bool error = false;
|
|
for (const auto& package : mFinalTable.packages) {
|
|
if (isExtPackageFunc(package)) {
|
|
// We have a package that is not related to the one we're building!
|
|
for (const auto& type : package->types) {
|
|
for (const auto& entry : type->entries) {
|
|
ResourceNameRef resName(package->name, type->type, entry->name);
|
|
|
|
for (const auto& configValue : entry->values) {
|
|
// Special case the occurrence of an ID that is being generated for the
|
|
// 'android' package. This is due to legacy reasons.
|
|
if (valueCast<Id>(configValue->value.get()) &&
|
|
package->name == u"android") {
|
|
mContext->getDiagnostics()->warn(
|
|
DiagMessage(configValue->value->getSource())
|
|
<< "generated id '" << resName
|
|
<< "' for external package '" << package->name
|
|
<< "'");
|
|
} else {
|
|
mContext->getDiagnostics()->error(
|
|
DiagMessage(configValue->value->getSource())
|
|
<< "defined resource '" << resName
|
|
<< "' for external package '" << package->name
|
|
<< "'");
|
|
error = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
auto newEndIter = std::remove_if(mFinalTable.packages.begin(), mFinalTable.packages.end(),
|
|
isExtPackageFunc);
|
|
mFinalTable.packages.erase(newEndIter, mFinalTable.packages.end());
|
|
return !error;
|
|
}
|
|
|
|
std::unique_ptr<IArchiveWriter> makeArchiveWriter() {
|
|
if (mOptions.outputToDirectory) {
|
|
return createDirectoryArchiveWriter(mContext->getDiagnostics(), mOptions.outputPath);
|
|
} else {
|
|
return createZipFileArchiveWriter(mContext->getDiagnostics(), mOptions.outputPath);
|
|
}
|
|
}
|
|
|
|
bool flattenTable(ResourceTable* table, IArchiveWriter* writer) {
|
|
BigBuffer buffer(1024);
|
|
TableFlattener flattener(&buffer);
|
|
if (!flattener.consume(mContext, table)) {
|
|
return false;
|
|
}
|
|
|
|
if (writer->startEntry("resources.arsc", ArchiveEntry::kAlign)) {
|
|
if (writer->writeEntry(buffer)) {
|
|
if (writer->finishEntry()) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
mContext->getDiagnostics()->error(
|
|
DiagMessage() << "failed to write resources.arsc to archive");
|
|
return false;
|
|
}
|
|
|
|
|
|
bool writeJavaFile(ResourceTable* table, const StringPiece16& packageNameToGenerate,
|
|
const StringPiece16& outPackage, JavaClassGeneratorOptions javaOptions) {
|
|
if (!mOptions.generateJavaClassPath) {
|
|
return true;
|
|
}
|
|
|
|
std::string outPath = mOptions.generateJavaClassPath.value();
|
|
file::appendPath(&outPath, file::packageToPath(util::utf16ToUtf8(outPackage)));
|
|
file::mkdirs(outPath);
|
|
file::appendPath(&outPath, "R.java");
|
|
|
|
std::ofstream fout(outPath, std::ofstream::binary);
|
|
if (!fout) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << strerror(errno));
|
|
return false;
|
|
}
|
|
|
|
JavaClassGenerator generator(table, javaOptions);
|
|
if (!generator.generate(packageNameToGenerate, outPackage, &fout)) {
|
|
mContext->getDiagnostics()->error(DiagMessage(outPath) << generator.getError());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool writeManifestJavaFile(xml::XmlResource* manifestXml) {
|
|
if (!mOptions.generateJavaClassPath) {
|
|
return true;
|
|
}
|
|
|
|
std::string outPath = mOptions.generateJavaClassPath.value();
|
|
file::appendPath(&outPath,
|
|
file::packageToPath(util::utf16ToUtf8(mContext->getCompilationPackage())));
|
|
file::mkdirs(outPath);
|
|
file::appendPath(&outPath, "Manifest.java");
|
|
|
|
std::ofstream fout(outPath, std::ofstream::binary);
|
|
if (!fout) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << strerror(errno));
|
|
return false;
|
|
}
|
|
|
|
ManifestClassGenerator generator;
|
|
if (!generator.generate(mContext->getDiagnostics(), mContext->getCompilationPackage(),
|
|
manifestXml, &fout)) {
|
|
return false;
|
|
}
|
|
|
|
if (!fout) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << strerror(errno));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool writeProguardFile(const proguard::KeepSet& keepSet) {
|
|
if (!mOptions.generateProguardRulesPath) {
|
|
return true;
|
|
}
|
|
|
|
std::ofstream fout(mOptions.generateProguardRulesPath.value(), std::ofstream::binary);
|
|
if (!fout) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << strerror(errno));
|
|
return false;
|
|
}
|
|
|
|
proguard::writeKeepSet(&fout, keepSet);
|
|
if (!fout) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << strerror(errno));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool mergeStaticLibrary(const std::string& input) {
|
|
// TODO(adamlesinski): Load resources from a static library APK and merge the table into
|
|
// TableMerger.
|
|
mContext->getDiagnostics()->warn(DiagMessage()
|
|
<< "linking static libraries not supported yet: "
|
|
<< input);
|
|
return true;
|
|
}
|
|
|
|
bool mergeResourceTable(io::IFile* file, bool override) {
|
|
if (mContext->verbose()) {
|
|
mContext->getDiagnostics()->note(DiagMessage() << "linking " << file->getSource());
|
|
}
|
|
|
|
std::unique_ptr<io::IData> data = file->openAsData();
|
|
if (!data) {
|
|
mContext->getDiagnostics()->error(DiagMessage(file->getSource())
|
|
<< "failed to open file");
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<ResourceTable> table = loadTableFromPb(file->getSource(),
|
|
data->data(), data->size(),
|
|
mContext->getDiagnostics());
|
|
if (!table) {
|
|
return false;
|
|
}
|
|
|
|
bool result = false;
|
|
if (override) {
|
|
result = mTableMerger->mergeOverlay(file->getSource(), table.get());
|
|
} else {
|
|
result = mTableMerger->merge(file->getSource(), table.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool mergeCompiledFile(io::IFile* file, std::unique_ptr<ResourceFile> fileDesc, bool overlay) {
|
|
if (mContext->verbose()) {
|
|
mContext->getDiagnostics()->note(DiagMessage() << "adding " << file->getSource());
|
|
}
|
|
|
|
bool result = false;
|
|
if (overlay) {
|
|
result = mTableMerger->mergeFileOverlay(*fileDesc, file);
|
|
} else {
|
|
result = mTableMerger->mergeFile(*fileDesc, file);
|
|
}
|
|
|
|
if (!result) {
|
|
return false;
|
|
}
|
|
|
|
// Add the exports of this file to the table.
|
|
for (SourcedResourceName& exportedSymbol : fileDesc->exportedSymbols) {
|
|
if (exportedSymbol.name.package.empty()) {
|
|
exportedSymbol.name.package = mContext->getCompilationPackage().toString();
|
|
}
|
|
|
|
ResourceNameRef resName = exportedSymbol.name;
|
|
|
|
Maybe<ResourceName> mangledName = mContext->getNameMangler()->mangleName(
|
|
exportedSymbol.name);
|
|
if (mangledName) {
|
|
resName = mangledName.value();
|
|
}
|
|
|
|
std::unique_ptr<Id> id = util::make_unique<Id>();
|
|
id->setSource(fileDesc->source.withLine(exportedSymbol.line));
|
|
bool result = mFinalTable.addResourceAllowMangled(resName,
|
|
ConfigDescription::defaultConfig(),
|
|
std::string(),
|
|
std::move(id),
|
|
mContext->getDiagnostics());
|
|
if (!result) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Creates an io::IFileCollection from the ZIP archive and processes the files within.
|
|
*/
|
|
bool mergeArchive(const std::string& input, bool override) {
|
|
std::string errorStr;
|
|
std::unique_ptr<io::ZipFileCollection> collection = io::ZipFileCollection::create(
|
|
input, &errorStr);
|
|
if (!collection) {
|
|
mContext->getDiagnostics()->error(DiagMessage(input) << errorStr);
|
|
return false;
|
|
}
|
|
|
|
bool error = false;
|
|
for (auto iter = collection->iterator(); iter->hasNext(); ) {
|
|
if (!processFile(iter->next(), override)) {
|
|
error = true;
|
|
}
|
|
}
|
|
|
|
// Make sure to move the collection into the set of IFileCollections.
|
|
mCollections.push_back(std::move(collection));
|
|
return !error;
|
|
}
|
|
|
|
bool processFile(const std::string& path, bool override) {
|
|
if (util::stringEndsWith<char>(path, ".flata") ||
|
|
util::stringEndsWith<char>(path, ".jar") ||
|
|
util::stringEndsWith<char>(path, ".jack") ||
|
|
util::stringEndsWith<char>(path, ".zip")) {
|
|
return mergeArchive(path, override);
|
|
}
|
|
|
|
io::IFile* file = mFileCollection->insertFile(path);
|
|
return processFile(file, override);
|
|
}
|
|
|
|
bool processFile(io::IFile* file, bool override) {
|
|
const Source& src = file->getSource();
|
|
if (util::stringEndsWith<char>(src.path, ".arsc.flat")) {
|
|
return mergeResourceTable(file, override);
|
|
} else if (util::stringEndsWith<char>(src.path, ".flat")){
|
|
// Try opening the file and looking for an Export header.
|
|
std::unique_ptr<io::IData> data = file->openAsData();
|
|
if (!data) {
|
|
mContext->getDiagnostics()->error(DiagMessage(src) << "failed to open");
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<ResourceFile> resourceFile = loadFileExportHeader(
|
|
src, data->data(), data->size(), mContext->getDiagnostics());
|
|
if (resourceFile) {
|
|
return mergeCompiledFile(file, std::move(resourceFile), override);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Ignore non .flat files. This could be classes.dex or something else that happens
|
|
// to be in an archive.
|
|
return true;
|
|
}
|
|
|
|
int run(const std::vector<std::string>& inputFiles) {
|
|
// Load the AndroidManifest.xml
|
|
std::unique_ptr<xml::XmlResource> manifestXml = loadXml(mOptions.manifestPath,
|
|
mContext->getDiagnostics());
|
|
if (!manifestXml) {
|
|
return 1;
|
|
}
|
|
|
|
if (Maybe<AppInfo> maybeAppInfo = extractAppInfoFromManifest(manifestXml.get())) {
|
|
mContext->mCompilationPackage = maybeAppInfo.value().package;
|
|
} else {
|
|
mContext->getDiagnostics()->error(DiagMessage(mOptions.manifestPath)
|
|
<< "no package specified in <manifest> tag");
|
|
return 1;
|
|
}
|
|
|
|
if (!util::isJavaPackageName(mContext->mCompilationPackage)) {
|
|
mContext->getDiagnostics()->error(DiagMessage(mOptions.manifestPath)
|
|
<< "invalid package name '"
|
|
<< mContext->mCompilationPackage
|
|
<< "'");
|
|
return 1;
|
|
}
|
|
|
|
mContext->mNameMangler = util::make_unique<NameMangler>(
|
|
NameManglerPolicy{ mContext->mCompilationPackage });
|
|
|
|
if (mContext->mCompilationPackage == u"android") {
|
|
mContext->mPackageId = 0x01;
|
|
} else {
|
|
mContext->mPackageId = 0x7f;
|
|
}
|
|
|
|
mContext->mSymbols = createSymbolTableFromIncludePaths();
|
|
if (!mContext->mSymbols) {
|
|
return 1;
|
|
}
|
|
|
|
TableMergerOptions tableMergerOptions;
|
|
tableMergerOptions.autoAddOverlay = mOptions.autoAddOverlay;
|
|
mTableMerger = util::make_unique<TableMerger>(mContext, &mFinalTable, tableMergerOptions);
|
|
|
|
if (mContext->verbose()) {
|
|
mContext->getDiagnostics()->note(
|
|
DiagMessage() << "linking package '" << mContext->mCompilationPackage << "' "
|
|
<< "with package ID " << std::hex << (int) mContext->mPackageId);
|
|
}
|
|
|
|
|
|
for (const std::string& input : inputFiles) {
|
|
if (!processFile(input, false)) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed parsing input");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
for (const std::string& input : mOptions.overlayFiles) {
|
|
if (!processFile(input, true)) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed parsing overlays");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (!verifyNoExternalPackages()) {
|
|
return 1;
|
|
}
|
|
|
|
if (!mOptions.staticLib) {
|
|
PrivateAttributeMover mover;
|
|
if (!mover.consume(mContext, &mFinalTable)) {
|
|
mContext->getDiagnostics()->error(
|
|
DiagMessage() << "failed moving private attributes");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
{
|
|
IdAssigner idAssigner;
|
|
if (!idAssigner.consume(mContext, &mFinalTable)) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed assigning IDs");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
mContext->mNameMangler = util::make_unique<NameMangler>(NameManglerPolicy{
|
|
mContext->mCompilationPackage, mTableMerger->getMergedPackages() });
|
|
mContext->mSymbols = JoinedSymbolTableBuilder()
|
|
.addSymbolTable(util::make_unique<SymbolTableWrapper>(&mFinalTable))
|
|
.addSymbolTable(std::move(mContext->mSymbols))
|
|
.build();
|
|
|
|
{
|
|
ReferenceLinker linker;
|
|
if (!linker.consume(mContext, &mFinalTable)) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed linking references");
|
|
return 1;
|
|
}
|
|
|
|
ProductFilter productFilter(mOptions.products);
|
|
if (!productFilter.consume(mContext, &mFinalTable)) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed stripping products");
|
|
return 1;
|
|
}
|
|
|
|
// TODO(adamlesinski): Actually pass in split constraints and handle splits at the file
|
|
// level.
|
|
TableSplitter tableSplitter({}, mOptions.tableSplitterOptions);
|
|
if (!tableSplitter.verifySplitConstraints(mContext)) {
|
|
return 1;
|
|
}
|
|
|
|
tableSplitter.splitTable(&mFinalTable);
|
|
}
|
|
|
|
proguard::KeepSet proguardKeepSet;
|
|
|
|
std::unique_ptr<IArchiveWriter> archiveWriter = makeArchiveWriter();
|
|
if (!archiveWriter) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed to create archive");
|
|
return 1;
|
|
}
|
|
|
|
bool error = false;
|
|
{
|
|
ManifestFixer manifestFixer(mOptions.manifestFixerOptions);
|
|
if (!manifestFixer.consume(mContext, manifestXml.get())) {
|
|
error = true;
|
|
}
|
|
|
|
// AndroidManifest.xml has no resource name, but the CallSite is built from the name
|
|
// (aka, which package the AndroidManifest.xml is coming from).
|
|
// So we give it a package name so it can see local resources.
|
|
manifestXml->file.name.package = mContext->getCompilationPackage().toString();
|
|
|
|
XmlReferenceLinker manifestLinker;
|
|
if (manifestLinker.consume(mContext, manifestXml.get())) {
|
|
if (!proguard::collectProguardRulesForManifest(Source(mOptions.manifestPath),
|
|
manifestXml.get(),
|
|
&proguardKeepSet)) {
|
|
error = true;
|
|
}
|
|
|
|
if (mOptions.generateJavaClassPath) {
|
|
if (!writeManifestJavaFile(manifestXml.get())) {
|
|
error = true;
|
|
}
|
|
}
|
|
|
|
const bool keepRawValues = mOptions.staticLib;
|
|
bool result = flattenXml(manifestXml.get(), "AndroidManifest.xml", {},
|
|
keepRawValues, archiveWriter.get(), mContext);
|
|
if (!result) {
|
|
error = true;
|
|
}
|
|
} else {
|
|
error = true;
|
|
}
|
|
}
|
|
|
|
if (error) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed processing manifest");
|
|
return 1;
|
|
}
|
|
|
|
ResourceFileFlattenerOptions fileFlattenerOptions;
|
|
fileFlattenerOptions.keepRawValues = mOptions.staticLib;
|
|
fileFlattenerOptions.doNotCompressAnything = mOptions.doNotCompressAnything;
|
|
fileFlattenerOptions.extensionsToNotCompress = mOptions.extensionsToNotCompress;
|
|
fileFlattenerOptions.noAutoVersion = mOptions.noAutoVersion;
|
|
ResourceFileFlattener fileFlattener(fileFlattenerOptions, mContext, &proguardKeepSet);
|
|
|
|
if (!fileFlattener.flatten(&mFinalTable, archiveWriter.get())) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed linking file resources");
|
|
return 1;
|
|
}
|
|
|
|
if (!mOptions.noAutoVersion) {
|
|
AutoVersioner versioner;
|
|
if (!versioner.consume(mContext, &mFinalTable)) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed versioning styles");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (!flattenTable(&mFinalTable, archiveWriter.get())) {
|
|
mContext->getDiagnostics()->error(DiagMessage() << "failed to write resources.arsc");
|
|
return 1;
|
|
}
|
|
|
|
if (mOptions.generateJavaClassPath) {
|
|
JavaClassGeneratorOptions options;
|
|
options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
|
|
|
|
if (mOptions.staticLib || mOptions.generateNonFinalIds) {
|
|
options.useFinal = false;
|
|
}
|
|
|
|
const StringPiece16 actualPackage = mContext->getCompilationPackage();
|
|
StringPiece16 outputPackage = mContext->getCompilationPackage();
|
|
if (mOptions.customJavaPackage) {
|
|
// Override the output java package to the custom one.
|
|
outputPackage = mOptions.customJavaPackage.value();
|
|
}
|
|
|
|
if (mOptions.privateSymbols) {
|
|
// If we defined a private symbols package, we only emit Public symbols
|
|
// to the original package, and private and public symbols to the private package.
|
|
|
|
options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
|
|
if (!writeJavaFile(&mFinalTable, mContext->getCompilationPackage(),
|
|
outputPackage, options)) {
|
|
return 1;
|
|
}
|
|
|
|
options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
|
|
outputPackage = mOptions.privateSymbols.value();
|
|
}
|
|
|
|
if (!writeJavaFile(&mFinalTable, actualPackage, outputPackage, options)) {
|
|
return 1;
|
|
}
|
|
|
|
for (const std::u16string& extraPackage : mOptions.extraJavaPackages) {
|
|
if (!writeJavaFile(&mFinalTable, actualPackage, extraPackage, options)) {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mOptions.generateProguardRulesPath) {
|
|
if (!writeProguardFile(proguardKeepSet)) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (mContext->verbose()) {
|
|
DebugPrintTableOptions debugPrintTableOptions;
|
|
debugPrintTableOptions.showSources = true;
|
|
Debug::printTable(&mFinalTable, debugPrintTableOptions);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
LinkOptions mOptions;
|
|
LinkContext* mContext;
|
|
ResourceTable mFinalTable;
|
|
|
|
ResourceTable mLocalFileTable;
|
|
std::unique_ptr<TableMerger> mTableMerger;
|
|
|
|
// A pointer to the FileCollection representing the filesystem (not archives).
|
|
io::FileCollection* mFileCollection;
|
|
|
|
// A vector of IFileCollections. This is mainly here to keep ownership of the collections.
|
|
std::vector<std::unique_ptr<io::IFileCollection>> mCollections;
|
|
};
|
|
|
|
int link(const std::vector<StringPiece>& args) {
|
|
LinkContext context;
|
|
LinkOptions options;
|
|
Maybe<std::string> privateSymbolsPackage;
|
|
Maybe<std::string> minSdkVersion, targetSdkVersion;
|
|
Maybe<std::string> renameManifestPackage, renameInstrumentationTargetPackage;
|
|
Maybe<std::string> versionCode, versionName;
|
|
Maybe<std::string> customJavaPackage;
|
|
std::vector<std::string> extraJavaPackages;
|
|
Maybe<std::string> configs;
|
|
Maybe<std::string> preferredDensity;
|
|
Maybe<std::string> productList;
|
|
bool legacyXFlag = false;
|
|
bool requireLocalization = false;
|
|
Flags flags = Flags()
|
|
.requiredFlag("-o", "Output path", &options.outputPath)
|
|
.requiredFlag("--manifest", "Path to the Android manifest to build",
|
|
&options.manifestPath)
|
|
.optionalFlagList("-I", "Adds an Android APK to link against", &options.includePaths)
|
|
.optionalFlagList("-R", "Compilation unit to link, using `overlay` semantics.\n"
|
|
"The last conflicting resource given takes precedence.",
|
|
&options.overlayFiles)
|
|
.optionalFlag("--java", "Directory in which to generate R.java",
|
|
&options.generateJavaClassPath)
|
|
.optionalFlag("--proguard", "Output file for generated Proguard rules",
|
|
&options.generateProguardRulesPath)
|
|
.optionalSwitch("--no-auto-version",
|
|
"Disables automatic style and layout SDK versioning",
|
|
&options.noAutoVersion)
|
|
.optionalSwitch("-x", "Legacy flag that specifies to use the package identifier 0x01",
|
|
&legacyXFlag)
|
|
.optionalSwitch("-z", "Require localization of strings marked 'suggested'",
|
|
&requireLocalization)
|
|
.optionalFlag("-c", "Comma separated list of configurations to include. The default\n"
|
|
"is all configurations", &configs)
|
|
.optionalFlag("--preferred-density",
|
|
"Selects the closest matching density and strips out all others.",
|
|
&preferredDensity)
|
|
.optionalFlag("--product", "Comma separated list of product names to keep",
|
|
&productList)
|
|
.optionalSwitch("--output-to-dir", "Outputs the APK contents to a directory specified "
|
|
"by -o",
|
|
&options.outputToDirectory)
|
|
.optionalFlag("--min-sdk-version", "Default minimum SDK version to use for "
|
|
"AndroidManifest.xml", &minSdkVersion)
|
|
.optionalFlag("--target-sdk-version", "Default target SDK version to use for "
|
|
"AndroidManifest.xml", &targetSdkVersion)
|
|
.optionalFlag("--version-code", "Version code (integer) to inject into the "
|
|
"AndroidManifest.xml if none is present", &versionCode)
|
|
.optionalFlag("--version-name", "Version name to inject into the AndroidManifest.xml "
|
|
"if none is present", &versionName)
|
|
.optionalSwitch("--static-lib", "Generate a static Android library", &options.staticLib)
|
|
.optionalSwitch("--non-final-ids", "Generates R.java without the final modifier.\n"
|
|
"This is implied when --static-lib is specified.",
|
|
&options.generateNonFinalIds)
|
|
.optionalFlag("--private-symbols", "Package name to use when generating R.java for "
|
|
"private symbols.\n"
|
|
"If not specified, public and private symbols will use the application's "
|
|
"package name", &privateSymbolsPackage)
|
|
.optionalFlag("--custom-package", "Custom Java package under which to generate R.java",
|
|
&customJavaPackage)
|
|
.optionalFlagList("--extra-packages", "Generate the same R.java but with different "
|
|
"package names", &extraJavaPackages)
|
|
.optionalSwitch("--auto-add-overlay", "Allows the addition of new resources in "
|
|
"overlays without <add-resource> tags", &options.autoAddOverlay)
|
|
.optionalFlag("--rename-manifest-package", "Renames the package in AndroidManifest.xml",
|
|
&renameManifestPackage)
|
|
.optionalFlag("--rename-instrumentation-target-package",
|
|
"Changes the name of the target package for instrumentation. Most useful "
|
|
"when used\nin conjunction with --rename-manifest-package",
|
|
&renameInstrumentationTargetPackage)
|
|
.optionalFlagList("-0", "File extensions not to compress",
|
|
&options.extensionsToNotCompress)
|
|
.optionalSwitch("-v", "Enables verbose logging", &context.mVerbose);
|
|
|
|
if (!flags.parse("aapt2 link", args, &std::cerr)) {
|
|
return 1;
|
|
}
|
|
|
|
if (privateSymbolsPackage) {
|
|
options.privateSymbols = util::utf8ToUtf16(privateSymbolsPackage.value());
|
|
}
|
|
|
|
if (minSdkVersion) {
|
|
options.manifestFixerOptions.minSdkVersionDefault =
|
|
util::utf8ToUtf16(minSdkVersion.value());
|
|
}
|
|
|
|
if (targetSdkVersion) {
|
|
options.manifestFixerOptions.targetSdkVersionDefault =
|
|
util::utf8ToUtf16(targetSdkVersion.value());
|
|
}
|
|
|
|
if (renameManifestPackage) {
|
|
options.manifestFixerOptions.renameManifestPackage =
|
|
util::utf8ToUtf16(renameManifestPackage.value());
|
|
}
|
|
|
|
if (renameInstrumentationTargetPackage) {
|
|
options.manifestFixerOptions.renameInstrumentationTargetPackage =
|
|
util::utf8ToUtf16(renameInstrumentationTargetPackage.value());
|
|
}
|
|
|
|
if (versionCode) {
|
|
options.manifestFixerOptions.versionCodeDefault = util::utf8ToUtf16(versionCode.value());
|
|
}
|
|
|
|
if (versionName) {
|
|
options.manifestFixerOptions.versionNameDefault = util::utf8ToUtf16(versionName.value());
|
|
}
|
|
|
|
if (customJavaPackage) {
|
|
options.customJavaPackage = util::utf8ToUtf16(customJavaPackage.value());
|
|
}
|
|
|
|
// Populate the set of extra packages for which to generate R.java.
|
|
for (std::string& extraPackage : extraJavaPackages) {
|
|
// A given package can actually be a colon separated list of packages.
|
|
for (StringPiece package : util::split(extraPackage, ':')) {
|
|
options.extraJavaPackages.insert(util::utf8ToUtf16(package));
|
|
}
|
|
}
|
|
|
|
if (productList) {
|
|
for (StringPiece product : util::tokenize<char>(productList.value(), ',')) {
|
|
if (product != "" && product != "default") {
|
|
options.products.insert(product.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
AxisConfigFilter filter;
|
|
if (configs) {
|
|
for (const StringPiece& configStr : util::tokenize<char>(configs.value(), ',')) {
|
|
ConfigDescription config;
|
|
LocaleValue lv;
|
|
if (lv.initFromFilterString(configStr)) {
|
|
lv.writeTo(&config);
|
|
} else if (!ConfigDescription::parse(configStr, &config)) {
|
|
context.getDiagnostics()->error(
|
|
DiagMessage() << "invalid config '" << configStr << "' for -c option");
|
|
return 1;
|
|
}
|
|
|
|
if (config.density != 0) {
|
|
context.getDiagnostics()->warn(
|
|
DiagMessage() << "ignoring density '" << config << "' for -c option");
|
|
} else {
|
|
filter.addConfig(config);
|
|
}
|
|
}
|
|
|
|
options.tableSplitterOptions.configFilter = &filter;
|
|
}
|
|
|
|
if (preferredDensity) {
|
|
ConfigDescription preferredDensityConfig;
|
|
if (!ConfigDescription::parse(preferredDensity.value(), &preferredDensityConfig)) {
|
|
context.getDiagnostics()->error(DiagMessage() << "invalid density '"
|
|
<< preferredDensity.value()
|
|
<< "' for --preferred-density option");
|
|
return 1;
|
|
}
|
|
|
|
// Clear the version that can be automatically added.
|
|
preferredDensityConfig.sdkVersion = 0;
|
|
|
|
if (preferredDensityConfig.diff(ConfigDescription::defaultConfig())
|
|
!= ConfigDescription::CONFIG_DENSITY) {
|
|
context.getDiagnostics()->error(DiagMessage() << "invalid preferred density '"
|
|
<< preferredDensity.value() << "'. "
|
|
<< "Preferred density must only be a density value");
|
|
return 1;
|
|
}
|
|
options.tableSplitterOptions.preferredDensity = preferredDensityConfig.density;
|
|
}
|
|
|
|
LinkCommand cmd(&context, options);
|
|
return cmd.run(flags.getArgs());
|
|
}
|
|
|
|
} // namespace aapt
|