1 /*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "MultiApkGenerator.h"
18
19 #include <algorithm>
20 #include <regex>
21 #include <string>
22
23 #include "androidfw/ConfigDescription.h"
24 #include "androidfw/StringPiece.h"
25
26 #include "LoadedApk.h"
27 #include "ResourceUtils.h"
28 #include "ValueVisitor.h"
29 #include "configuration/ConfigurationParser.h"
30 #include "cmd/Util.h"
31 #include "filter/AbiFilter.h"
32 #include "filter/Filter.h"
33 #include "format/Archive.h"
34 #include "format/binary/XmlFlattener.h"
35 #include "optimize/VersionCollapser.h"
36 #include "process/IResourceTableConsumer.h"
37 #include "split/TableSplitter.h"
38 #include "util/Files.h"
39 #include "xml/XmlDom.h"
40 #include "xml/XmlUtil.h"
41
42 namespace aapt {
43
44 using ::aapt::configuration::AndroidSdk;
45 using ::aapt::configuration::OutputArtifact;
46 using ::aapt::xml::kSchemaAndroid;
47 using ::aapt::xml::XmlResource;
48 using ::android::ConfigDescription;
49 using ::android::StringPiece;
50
51 /**
52 * Context wrapper that allows the min Android SDK value to be overridden.
53 */
54 class ContextWrapper : public IAaptContext {
55 public:
ContextWrapper(IAaptContext * context)56 explicit ContextWrapper(IAaptContext* context)
57 : context_(context), min_sdk_(context_->GetMinSdkVersion()) {
58 }
59
GetPackageType()60 PackageType GetPackageType() override {
61 return context_->GetPackageType();
62 }
63
GetExternalSymbols()64 SymbolTable* GetExternalSymbols() override {
65 return context_->GetExternalSymbols();
66 }
67
GetDiagnostics()68 android::IDiagnostics* GetDiagnostics() override {
69 if (source_diag_) {
70 return source_diag_.get();
71 }
72 return context_->GetDiagnostics();
73 }
74
GetCompilationPackage()75 const std::string& GetCompilationPackage() override {
76 return context_->GetCompilationPackage();
77 }
78
GetPackageId()79 uint8_t GetPackageId() override {
80 return context_->GetPackageId();
81 }
82
GetNameMangler()83 NameMangler* GetNameMangler() override {
84 return context_->GetNameMangler();
85 }
86
IsVerbose()87 bool IsVerbose() override {
88 return context_->IsVerbose();
89 }
90
GetMinSdkVersion()91 int GetMinSdkVersion() override {
92 return min_sdk_;
93 }
94
SetMinSdkVersion(int min_sdk)95 void SetMinSdkVersion(int min_sdk) {
96 min_sdk_ = min_sdk;
97 }
98
SetSource(const std::string & source)99 void SetSource(const std::string& source) {
100 source_diag_ = util::make_unique<android::SourcePathDiagnostics>(android::Source{source},
101 context_->GetDiagnostics());
102 }
103
GetSplitNameDependencies()104 const std::set<std::string>& GetSplitNameDependencies() override {
105 return context_->GetSplitNameDependencies();
106 }
107
108 private:
109 IAaptContext* context_;
110 std::unique_ptr<android::SourcePathDiagnostics> source_diag_;
111
112 int min_sdk_ = -1;
113 };
114
115 class SignatureFilter : public IPathFilter {
Keep(std::string_view path)116 bool Keep(std::string_view path) override {
117 static std::regex signature_regex(R"regex(^META-INF/.*\.(RSA|DSA|EC|SF)$)regex");
118 if (std::regex_search(path.begin(), path.end(), signature_regex)) {
119 return false;
120 }
121 return path != "META-INF/MANIFEST.MF";
122 }
123 };
124
MultiApkGenerator(LoadedApk * apk,IAaptContext * context)125 MultiApkGenerator::MultiApkGenerator(LoadedApk* apk, IAaptContext* context)
126 : apk_(apk), context_(context) {
127 }
128
FromBaseApk(const MultiApkGeneratorOptions & options)129 bool MultiApkGenerator::FromBaseApk(const MultiApkGeneratorOptions& options) {
130 std::unordered_set<std::string> artifacts_to_keep = options.kept_artifacts;
131 std::unordered_set<std::string> filtered_artifacts;
132 std::unordered_set<std::string> kept_artifacts;
133
134 // For now, just write out the stripped APK since ABI splitting doesn't modify anything else.
135 for (const OutputArtifact& artifact : options.apk_artifacts) {
136 FilterChain filters;
137
138 ContextWrapper wrapped_context{context_};
139 wrapped_context.SetSource(artifact.name);
140
141 if (!options.kept_artifacts.empty()) {
142 const auto& it = artifacts_to_keep.find(artifact.name);
143 if (it == artifacts_to_keep.end()) {
144 filtered_artifacts.insert(artifact.name);
145 if (context_->IsVerbose()) {
146 context_->GetDiagnostics()->Note(android::DiagMessage(artifact.name)
147 << "skipping artifact");
148 }
149 continue;
150 } else {
151 artifacts_to_keep.erase(it);
152 kept_artifacts.insert(artifact.name);
153 }
154 }
155
156 std::unique_ptr<ResourceTable> table =
157 FilterTable(context_, artifact, *apk_->GetResourceTable(), &filters);
158 if (!table) {
159 return false;
160 }
161
162 android::IDiagnostics* diag = wrapped_context.GetDiagnostics();
163
164 std::unique_ptr<XmlResource> manifest;
165 if (!UpdateManifest(artifact, &manifest, diag)) {
166 diag->Error(android::DiagMessage()
167 << "could not update AndroidManifest.xml for output artifact");
168 return false;
169 }
170
171 std::string out = options.out_dir;
172 if (!file::mkdirs(out)) {
173 diag->Warn(android::DiagMessage() << "could not create out dir: " << out);
174 }
175 file::AppendPath(&out, artifact.name);
176
177 if (context_->IsVerbose()) {
178 diag->Note(android::DiagMessage() << "Generating split: " << out);
179 }
180
181 std::unique_ptr<IArchiveWriter> writer = CreateZipFileArchiveWriter(diag, out);
182
183 if (context_->IsVerbose()) {
184 diag->Note(android::DiagMessage() << "Writing output: " << out);
185 }
186
187 filters.AddFilter(util::make_unique<SignatureFilter>());
188 if (!apk_->WriteToArchive(&wrapped_context, table.get(), options.table_flattener_options,
189 &filters, writer.get(), manifest.get())) {
190 return false;
191 }
192 }
193
194 // Make sure all of the requested artifacts were valid. If there are any kept artifacts left,
195 // either the config or the command line was wrong.
196 if (!artifacts_to_keep.empty()) {
197 context_->GetDiagnostics()
198 ->Error(android::DiagMessage()
199 << "The configuration and command line to filter artifacts do not match");
200
201 context_->GetDiagnostics()->Error(android::DiagMessage() << kept_artifacts.size() << " kept:");
202 for (const auto& artifact : kept_artifacts) {
203 context_->GetDiagnostics()->Error(android::DiagMessage() << " " << artifact);
204 }
205
206 context_->GetDiagnostics()->Error(android::DiagMessage()
207 << filtered_artifacts.size() << " filtered:");
208 for (const auto& artifact : filtered_artifacts) {
209 context_->GetDiagnostics()->Error(android::DiagMessage() << " " << artifact);
210 }
211
212 context_->GetDiagnostics()->Error(android::DiagMessage()
213 << artifacts_to_keep.size() << " missing:");
214 for (const auto& artifact : artifacts_to_keep) {
215 context_->GetDiagnostics()->Error(android::DiagMessage() << " " << artifact);
216 }
217
218 return false;
219 }
220
221 return true;
222 }
223
FilterTable(IAaptContext * context,const OutputArtifact & artifact,const ResourceTable & old_table,FilterChain * filters)224 std::unique_ptr<ResourceTable> MultiApkGenerator::FilterTable(IAaptContext* context,
225 const OutputArtifact& artifact,
226 const ResourceTable& old_table,
227 FilterChain* filters) {
228 TableSplitterOptions splits;
229 AxisConfigFilter axis_filter;
230 ContextWrapper wrapped_context{context};
231 wrapped_context.SetSource(artifact.name);
232
233 if (!artifact.abis.empty()) {
234 filters->AddFilter(AbiFilter::FromAbiList(artifact.abis));
235 }
236
237 if (!artifact.screen_densities.empty()) {
238 for (const auto& density_config : artifact.screen_densities) {
239 splits.preferred_densities.push_back(density_config.density);
240 }
241 }
242
243 if (!artifact.locales.empty()) {
244 for (const auto& locale : artifact.locales) {
245 axis_filter.AddConfig(locale);
246 }
247 splits.config_filter = &axis_filter;
248 }
249
250 if (artifact.android_sdk) {
251 wrapped_context.SetMinSdkVersion(artifact.android_sdk.value().min_sdk_version);
252 }
253
254 std::unique_ptr<ResourceTable> table = old_table.Clone();
255
256 VersionCollapser collapser;
257 if (!collapser.Consume(&wrapped_context, table.get())) {
258 context->GetDiagnostics()->Error(android::DiagMessage()
259 << "Failed to strip versioned resources");
260 return {};
261 }
262
263 TableSplitter splitter{{}, splits};
264 splitter.SplitTable(table.get());
265 return table;
266 }
267
UpdateManifest(const OutputArtifact & artifact,std::unique_ptr<XmlResource> * updated_manifest,android::IDiagnostics * diag)268 bool MultiApkGenerator::UpdateManifest(const OutputArtifact& artifact,
269 std::unique_ptr<XmlResource>* updated_manifest,
270 android::IDiagnostics* diag) {
271 const xml::XmlResource* apk_manifest = apk_->GetManifest();
272 if (apk_manifest == nullptr) {
273 return false;
274 }
275
276 *updated_manifest = apk_manifest->Clone();
277 XmlResource* manifest = updated_manifest->get();
278
279 // Make sure the first element is <manifest> with package attribute.
280 xml::Element* manifest_el = manifest->root.get();
281 if (!manifest_el) {
282 return false;
283 }
284
285 if (!manifest_el->namespace_uri.empty() || manifest_el->name != "manifest") {
286 diag->Error(android::DiagMessage(manifest->file.source) << "root tag must be <manifest>");
287 return false;
288 }
289
290 // Retrieve the versionCode attribute.
291 auto version_code = manifest_el->FindAttribute(kSchemaAndroid, "versionCode");
292 if (!version_code) {
293 diag->Error(android::DiagMessage(manifest->file.source)
294 << "manifest must have a versionCode attribute");
295 return false;
296 }
297
298 auto version_code_value = ValueCast<BinaryPrimitive>(version_code->compiled_value.get());
299 if (!version_code_value) {
300 diag->Error(android::DiagMessage(manifest->file.source) << "versionCode is invalid");
301 return false;
302 }
303
304 // Retrieve the versionCodeMajor attribute.
305 auto version_code_major = manifest_el->FindAttribute(kSchemaAndroid, "versionCodeMajor");
306 BinaryPrimitive* version_code_major_value = nullptr;
307 if (version_code_major) {
308 version_code_major_value = ValueCast<BinaryPrimitive>(version_code_major->compiled_value.get());
309 if (!version_code_major_value) {
310 diag->Error(android::DiagMessage(manifest->file.source) << "versionCodeMajor is invalid");
311 return false;
312 }
313 }
314
315 // Calculate and set the updated version code
316 uint64_t major = (version_code_major_value)
317 ? ((uint64_t) version_code_major_value->value.data) << 32 : 0;
318 uint64_t new_version = (major | version_code_value->value.data) + artifact.version;
319 SetLongVersionCode(manifest_el, new_version);
320
321 // Check to see if the minSdkVersion needs to be updated.
322 if (artifact.android_sdk) {
323 // TODO(safarmer): Handle the rest of the Android SDK.
324 const AndroidSdk& android_sdk = artifact.android_sdk.value();
325
326 if (xml::Element* uses_sdk_el = manifest_el->FindChild({}, "uses-sdk")) {
327 if (xml::Attribute* min_sdk_attr =
328 uses_sdk_el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion")) {
329 // Populate with a pre-compiles attribute to we don't need to relink etc.
330 const std::string& min_sdk_str = std::to_string(android_sdk.min_sdk_version);
331 min_sdk_attr->compiled_value = ResourceUtils::TryParseInt(min_sdk_str);
332 } else {
333 // There was no minSdkVersion. This is strange since at this point we should have been
334 // through the manifest fixer which sets the default minSdkVersion.
335 diag->Error(android::DiagMessage(manifest->file.source)
336 << "missing minSdkVersion from <uses-sdk>");
337 return false;
338 }
339 } else {
340 // No uses-sdk present. This is strange since at this point we should have been
341 // through the manifest fixer which should have added it.
342 diag->Error(android::DiagMessage(manifest->file.source)
343 << "missing <uses-sdk> from <manifest>");
344 return false;
345 }
346 }
347
348 if (!artifact.screen_densities.empty()) {
349 xml::Element* screens_el = manifest_el->FindChild({}, "compatible-screens");
350 if (!screens_el) {
351 // create a new element.
352 std::unique_ptr<xml::Element> new_screens_el = util::make_unique<xml::Element>();
353 new_screens_el->name = "compatible-screens";
354 screens_el = new_screens_el.get();
355 manifest_el->AppendChild(std::move(new_screens_el));
356 } else {
357 // clear out the old element.
358 screens_el->GetChildElements().clear();
359 }
360
361 for (const auto& density : artifact.screen_densities) {
362 AddScreens(density, screens_el);
363 }
364 }
365
366 return true;
367 }
368
369 /**
370 * Adds a screen element with both screenSize and screenDensity set. Since we only know the density
371 * we add it for all screen sizes.
372 *
373 * This requires the resource IDs for the attributes from the framework library. Since these IDs are
374 * a part of the public API (and in public.xml) we hard code the values.
375 *
376 * The excert from the framework is as follows:
377 * <public type="attr" name="screenSize" id="0x010102ca" />
378 * <public type="attr" name="screenDensity" id="0x010102cb" />
379 */
AddScreens(const ConfigDescription & config,xml::Element * parent)380 void MultiApkGenerator::AddScreens(const ConfigDescription& config, xml::Element* parent) {
381 // Hard coded integer representation of the supported screen sizes:
382 // small = 200
383 // normal = 300
384 // large = 400
385 // xlarge = 500
386 constexpr const uint32_t kScreenSizes[4] = {200, 300, 400, 500,};
387 constexpr const uint32_t kScreenSizeResourceId = 0x010102ca;
388 constexpr const uint32_t kScreenDensityResourceId = 0x010102cb;
389
390 for (uint32_t screen_size : kScreenSizes) {
391 std::unique_ptr<xml::Element> screen = util::make_unique<xml::Element>();
392 screen->name = "screen";
393
394 xml::Attribute* size = screen->FindOrCreateAttribute(kSchemaAndroid, "screenSize");
395 size->compiled_attribute = xml::AaptAttribute(Attribute(), {kScreenSizeResourceId});
396 size->compiled_value = ResourceUtils::MakeInt(screen_size);
397
398 xml::Attribute* density = screen->FindOrCreateAttribute(kSchemaAndroid, "screenDensity");
399 density->compiled_attribute = xml::AaptAttribute(Attribute(), {kScreenDensityResourceId});
400 density->compiled_value = ResourceUtils::MakeInt(config.density);
401
402
403 parent->AppendChild(std::move(screen));
404 }
405 }
406
407 } // namespace aapt
408