1 /*
2  * Copyright (C) 2014 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 <algorithm>
18 #include <cstdio>
19 
20 #include "aapt/AaptUtil.h"
21 
22 #include "Grouper.h"
23 #include "Rule.h"
24 #include "RuleGenerator.h"
25 #include "SplitDescription.h"
26 #include "SplitSelector.h"
27 
28 #include <androidfw/AssetManager.h>
29 #include <androidfw/ResourceTypes.h>
30 #include <utils/KeyedVector.h>
31 #include <utils/Vector.h>
32 
33 using namespace android;
34 
35 namespace split {
36 
usage()37 static void usage() {
38     fprintf(stderr,
39             "split-select --help\n"
40             "split-select --target <config> --base <path/to/apk> [--split <path/to/apk> [...]]\n"
41             "split-select --generate --base <path/to/apk> [--split <path/to/apk> [...]]\n"
42             "\n"
43             "  --help                   Displays more information about this program.\n"
44             "  --target <config>        Performs the Split APK selection on the given configuration.\n"
45             "  --generate               Generates the logic for selecting the Split APK, in JSON format.\n"
46             "  --base <path/to/apk>     Specifies the base APK, from which all Split APKs must be based off.\n"
47             "  --split <path/to/apk>    Includes a Split APK in the selection process.\n"
48             "\n"
49             "  Where <config> is an extended AAPT resource qualifier of the form\n"
50             "  'resource-qualifiers:extended-qualifiers', where 'resource-qualifiers' is an AAPT resource\n"
51             "  qualifier (ex: en-rUS-sw600dp-xhdpi), and 'extended-qualifiers' is an ordered list of one\n"
52             "  qualifier (or none) from each category:\n"
53             "    Architecture: armeabi, armeabi-v7a, arm64-v8a, x86, x86_64, mips\n");
54 }
55 
help()56 static void help() {
57     usage();
58     fprintf(stderr, "\n"
59             "  Generates the logic for selecting a Split APK given some target Android device configuration.\n"
60             "  Using the flag --generate will emit a JSON encoded tree of rules that must be satisfied in order\n"
61             "  to install the given Split APK. Using the flag --target along with the device configuration\n"
62             "  will emit the set of Split APKs to install, following the same logic that would have been emitted\n"
63             "  via JSON.\n");
64 }
65 
select(const SplitDescription & target,const Vector<SplitDescription> & splits)66 Vector<SplitDescription> select(const SplitDescription& target, const Vector<SplitDescription>& splits) {
67     const SplitSelector selector(splits);
68     return selector.getBestSplits(target);
69 }
70 
generate(const KeyedVector<String8,Vector<SplitDescription>> & splits,const String8 & base)71 void generate(const KeyedVector<String8, Vector<SplitDescription> >& splits, const String8& base) {
72     Vector<SplitDescription> allSplits;
73     const size_t apkSplitCount = splits.size();
74     for (size_t i = 0; i < apkSplitCount; i++) {
75         allSplits.appendVector(splits[i]);
76     }
77     const SplitSelector selector(allSplits);
78     KeyedVector<SplitDescription, sp<Rule> > rules(selector.getRules());
79 
80     bool first = true;
81     fprintf(stdout, "[\n");
82     for (size_t i = 0; i < apkSplitCount; i++) {
83         if (splits.keyAt(i) == base) {
84             // Skip the base.
85             continue;
86         }
87 
88         if (!first) {
89             fprintf(stdout, ",\n");
90         }
91         first = false;
92 
93         sp<Rule> masterRule = new Rule();
94         masterRule->op = Rule::OR_SUBRULES;
95         const Vector<SplitDescription>& splitDescriptions = splits[i];
96         const size_t splitDescriptionCount = splitDescriptions.size();
97         for (size_t j = 0; j < splitDescriptionCount; j++) {
98             masterRule->subrules.add(rules.valueFor(splitDescriptions[j]));
99         }
100         masterRule = Rule::simplify(masterRule);
101         fprintf(stdout, "  {\n    \"path\": \"%s\",\n    \"rules\": %s\n  }",
102                 splits.keyAt(i).string(),
103                 masterRule->toJson(2).string());
104     }
105     fprintf(stdout, "\n]\n");
106 }
107 
removeRuntimeQualifiers(ConfigDescription * outConfig)108 static void removeRuntimeQualifiers(ConfigDescription* outConfig) {
109     outConfig->imsi = 0;
110     outConfig->orientation = ResTable_config::ORIENTATION_ANY;
111     outConfig->screenWidth = ResTable_config::SCREENWIDTH_ANY;
112     outConfig->screenHeight = ResTable_config::SCREENHEIGHT_ANY;
113     outConfig->uiMode &= ResTable_config::UI_MODE_NIGHT_ANY;
114 }
115 
116 struct AppInfo {
117     int versionCode;
118     int minSdkVersion;
119     bool multiArch;
120 };
121 
getAppInfo(const String8 & path,AppInfo & outInfo)122 static bool getAppInfo(const String8& path, AppInfo& outInfo) {
123     memset(&outInfo, 0, sizeof(outInfo));
124 
125     AssetManager assetManager;
126     int32_t cookie = 0;
127     if (!assetManager.addAssetPath(path, &cookie)) {
128         return false;
129     }
130 
131     Asset* asset = assetManager.openNonAsset(cookie, "AndroidManifest.xml", Asset::ACCESS_BUFFER);
132     if (asset == NULL) {
133         return false;
134     }
135 
136     ResXMLTree xml;
137     if (xml.setTo(asset->getBuffer(true), asset->getLength(), false) != NO_ERROR) {
138         delete asset;
139         return false;
140     }
141 
142     const String16 kAndroidNamespace("http://schemas.android.com/apk/res/android");
143     const String16 kManifestTag("manifest");
144     const String16 kApplicationTag("application");
145     const String16 kUsesSdkTag("uses-sdk");
146     const String16 kVersionCodeAttr("versionCode");
147     const String16 kMultiArchAttr("multiArch");
148     const String16 kMinSdkVersionAttr("minSdkVersion");
149 
150     ResXMLParser::event_code_t event;
151     while ((event = xml.next()) != ResXMLParser::BAD_DOCUMENT &&
152             event != ResXMLParser::END_DOCUMENT) {
153         if (event != ResXMLParser::START_TAG) {
154             continue;
155         }
156 
157         size_t len;
158         const char16_t* name = xml.getElementName(&len);
159         String16 name16(name, len);
160         if (name16 == kManifestTag) {
161             ssize_t idx = xml.indexOfAttribute(
162                     kAndroidNamespace.string(), kAndroidNamespace.size(),
163                     kVersionCodeAttr.string(), kVersionCodeAttr.size());
164             if (idx >= 0) {
165                 outInfo.versionCode = xml.getAttributeData(idx);
166             }
167 
168         } else if (name16 == kApplicationTag) {
169             ssize_t idx = xml.indexOfAttribute(
170                     kAndroidNamespace.string(), kAndroidNamespace.size(),
171                     kMultiArchAttr.string(), kMultiArchAttr.size());
172             if (idx >= 0) {
173                 outInfo.multiArch = xml.getAttributeData(idx) != 0;
174             }
175 
176         } else if (name16 == kUsesSdkTag) {
177             ssize_t idx = xml.indexOfAttribute(
178                     kAndroidNamespace.string(), kAndroidNamespace.size(),
179                     kMinSdkVersionAttr.string(), kMinSdkVersionAttr.size());
180             if (idx >= 0) {
181                 uint16_t type = xml.getAttributeDataType(idx);
182                 if (type >= Res_value::TYPE_FIRST_INT && type <= Res_value::TYPE_LAST_INT) {
183                     outInfo.minSdkVersion = xml.getAttributeData(idx);
184                 } else if (type == Res_value::TYPE_STRING) {
185                     String8 minSdk8(xml.getStrings().string8ObjectAt(idx));
186                     char* endPtr;
187                     int minSdk = strtol(minSdk8.string(), &endPtr, 10);
188                     if (endPtr != minSdk8.string() + minSdk8.size()) {
189                         fprintf(stderr, "warning: failed to parse android:minSdkVersion '%s'\n",
190                                 minSdk8.string());
191                     } else {
192                         outInfo.minSdkVersion = minSdk;
193                     }
194                 } else {
195                     fprintf(stderr, "warning: unrecognized value for android:minSdkVersion.\n");
196                 }
197             }
198         }
199     }
200 
201     delete asset;
202     return true;
203 }
204 
extractSplitDescriptionsFromApk(const String8 & path)205 static Vector<SplitDescription> extractSplitDescriptionsFromApk(const String8& path) {
206     AssetManager assetManager;
207     Vector<SplitDescription> splits;
208     int32_t cookie = 0;
209     if (!assetManager.addAssetPath(path, &cookie)) {
210         return splits;
211     }
212 
213     const ResTable& res = assetManager.getResources(false);
214     if (res.getError() == NO_ERROR) {
215         Vector<ResTable_config> configs;
216         res.getConfigurations(&configs, true);
217         const size_t configCount = configs.size();
218         for (size_t i = 0; i < configCount; i++) {
219             splits.add();
220             splits.editTop().config = configs[i];
221         }
222     }
223 
224     AssetDir* dir = assetManager.openNonAssetDir(cookie, "lib");
225     if (dir != NULL) {
226         const size_t fileCount = dir->getFileCount();
227         for (size_t i = 0; i < fileCount; i++) {
228             splits.add();
229             Vector<String8> parts = AaptUtil::splitAndLowerCase(dir->getFileName(i), '-');
230             if (parseAbi(parts, 0, &splits.editTop()) < 0) {
231                 fprintf(stderr, "Malformed library %s\n", dir->getFileName(i).string());
232                 splits.pop();
233             }
234         }
235         delete dir;
236     }
237     return splits;
238 }
239 
main(int argc,char ** argv)240 static int main(int argc, char** argv) {
241     // Skip over the first argument.
242     argc--;
243     argv++;
244 
245     bool generateFlag = false;
246     String8 targetConfigStr;
247     Vector<String8> splitApkPaths;
248     String8 baseApkPath;
249     while (argc > 0) {
250         const String8 arg(*argv);
251         if (arg == "--target") {
252             argc--;
253             argv++;
254             if (argc < 1) {
255                 fprintf(stderr, "error: missing parameter for --target.\n");
256                 usage();
257                 return 1;
258             }
259             targetConfigStr.setTo(*argv);
260         } else if (arg == "--split") {
261             argc--;
262             argv++;
263             if (argc < 1) {
264                 fprintf(stderr, "error: missing parameter for --split.\n");
265                 usage();
266                 return 1;
267             }
268             splitApkPaths.add(String8(*argv));
269         } else if (arg == "--base") {
270             argc--;
271             argv++;
272             if (argc < 1) {
273                 fprintf(stderr, "error: missing parameter for --base.\n");
274                 usage();
275                 return 1;
276             }
277 
278             if (baseApkPath.size() > 0) {
279                 fprintf(stderr, "error: multiple --base flags not allowed.\n");
280                 usage();
281                 return 1;
282             }
283             baseApkPath.setTo(*argv);
284         } else if (arg == "--generate") {
285             generateFlag = true;
286         } else if (arg == "--help") {
287             help();
288             return 0;
289         } else {
290             fprintf(stderr, "error: unknown argument '%s'.\n", arg.string());
291             usage();
292             return 1;
293         }
294         argc--;
295         argv++;
296     }
297 
298     if (!generateFlag && targetConfigStr == "") {
299         usage();
300         return 1;
301     }
302 
303     if (baseApkPath.size() == 0) {
304         fprintf(stderr, "error: missing --base argument.\n");
305         usage();
306         return 1;
307     }
308 
309     // Find out some details about the base APK.
310     AppInfo baseAppInfo;
311     if (!getAppInfo(baseApkPath, baseAppInfo)) {
312         fprintf(stderr, "error: unable to read base APK: '%s'.\n", baseApkPath.string());
313         return 1;
314     }
315 
316     SplitDescription targetSplit;
317     if (!generateFlag) {
318         if (!SplitDescription::parse(targetConfigStr, &targetSplit)) {
319             fprintf(stderr, "error: invalid --target config: '%s'.\n",
320                     targetConfigStr.string());
321             usage();
322             return 1;
323         }
324 
325         // We don't want to match on things that will change at run-time
326         // (orientation, w/h, etc.).
327         removeRuntimeQualifiers(&targetSplit.config);
328     }
329 
330     splitApkPaths.add(baseApkPath);
331 
332     KeyedVector<String8, Vector<SplitDescription> > apkPathSplitMap;
333     KeyedVector<SplitDescription, String8> splitApkPathMap;
334     Vector<SplitDescription> splitConfigs;
335     const size_t splitCount = splitApkPaths.size();
336     for (size_t i = 0; i < splitCount; i++) {
337         Vector<SplitDescription> splits = extractSplitDescriptionsFromApk(splitApkPaths[i]);
338         if (splits.isEmpty()) {
339             fprintf(stderr, "error: invalid --split path: '%s'. No splits found.\n",
340                     splitApkPaths[i].string());
341             usage();
342             return 1;
343         }
344         apkPathSplitMap.replaceValueFor(splitApkPaths[i], splits);
345         const size_t apkSplitDescriptionCount = splits.size();
346         for (size_t j = 0; j < apkSplitDescriptionCount; j++) {
347             splitApkPathMap.replaceValueFor(splits[j], splitApkPaths[i]);
348         }
349         splitConfigs.appendVector(splits);
350     }
351 
352     if (!generateFlag) {
353         Vector<SplitDescription> matchingConfigs = select(targetSplit, splitConfigs);
354         const size_t matchingConfigCount = matchingConfigs.size();
355         SortedVector<String8> matchingSplitPaths;
356         for (size_t i = 0; i < matchingConfigCount; i++) {
357             matchingSplitPaths.add(splitApkPathMap.valueFor(matchingConfigs[i]));
358         }
359 
360         const size_t matchingSplitApkPathCount = matchingSplitPaths.size();
361         for (size_t i = 0; i < matchingSplitApkPathCount; i++) {
362             if (matchingSplitPaths[i] != baseApkPath) {
363                 fprintf(stdout, "%s\n", matchingSplitPaths[i].string());
364             }
365         }
366     } else {
367         generate(apkPathSplitMap, baseApkPath);
368     }
369     return 0;
370 }
371 
372 } // namespace split
373 
main(int argc,char ** argv)374 int main(int argc, char** argv) {
375     return split::main(argc, argv);
376 }
377