-
Notifications
You must be signed in to change notification settings - Fork 1
/
fat-aar.gradle
474 lines (385 loc) · 16.9 KB
/
fat-aar.gradle
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
import com.android.annotations.NonNull
import com.android.manifmerger.ManifestMerger2
import com.android.manifmerger.ManifestMerger2.Invoker
import com.android.manifmerger.ManifestMerger2.MergeType
import com.android.manifmerger.MergingReport
import com.android.manifmerger.PlaceholderEncoder
import com.android.manifmerger.XmlDocument
import com.android.utils.ILogger
import com.google.common.base.Charsets
import com.google.common.io.Files
buildscript {
repositories {
jcenter()
google()
}
dependencies {
classpath 'com.android.tools.build:manifest-merger:26.2.1'
}
}
configurations {
embedded
}
dependencies {
implementation configurations.embedded
}
// Paths to embedded jar files
ext.embeddedJars = new ArrayList()
// Paths to embedded aar projects
ext.embeddedAarDirs = new ArrayList()
// Embedded aar files dependencies
ext.embeddedAarFiles = new ArrayList<ResolvedArtifact>()
// List of embedded R classes
ext.embeddedRClasses = new ArrayList()
// Change backslash to forward slash on windows
ext.build_dir = buildDir.path.replace(File.separator, '/');
ext.root_dir = project.rootDir.absolutePath.replace(File.separator, '/');
ext.exploded_aar_dir = "$build_dir/intermediates/exploded-aar";
ext.classs_release_dir = "$build_dir/intermediates/javac/release/compileReleaseJavaWithJavac/classes";
//ext.bundle_release_dir = "$build_dir/intermediates/bundles/default";
ext.manifest_aaapt_dir = "$build_dir/intermediates/aapt_friendly_merged_manifests/release/processReleaseManifest/aapt";
ext.generated_rsrc_dir = "$build_dir/generated/not_namespaced_r_class_sources/release/generateReleaseRFile/out";
ext.base_r2x_dir = "$build_dir/fat-aar/release/";
def gradleVersionStr = GradleVersion.current().getVersion();
ext.gradleApiVersion = gradleVersionStr.substring(0, gradleVersionStr.lastIndexOf(".")).toFloat();
println "Gradle version: " + gradleVersionStr;
afterEvaluate {
// STEP: 1 -> This should be the first to run
// Creating embeddedAarDirs and embeddedAarFiles list for use in the script.
// the list of dependency must be reversed to use the right overlay order.
def dependencies = new ArrayList(configurations.embedded.resolvedConfiguration.firstLevelModuleDependencies)
dependencies.reverseEach {
def aarPath = "${root_dir}/aarlibs/${it.moduleName}/build/intermediates/bundles/default";
it.moduleArtifacts.each {
artifact ->
println "ARTIFACT: ${artifact}"
if (artifact.type == 'aar') {
if (!embeddedAarFiles.contains(artifact)) {
println "Adding Artifact File into embeddedAarFiles => ${artifact}"
embeddedAarFiles.add(artifact)
}
if (!embeddedAarDirs.contains(aarPath)) {
if( artifact.file.isFile() ){
println "Artifact file => ${artifact.file}"
println "AarPath => ${aarPath}"
println "Extracting ${artifact.file} to ${aarPath}"
copy {
from zipTree( artifact.file )
into aarPath
}
}
println "Adding Artifact Dir into embeddedAarDirs: ${aarPath}"
embeddedAarDirs.add(aarPath)
}
} else if (artifact.type == 'jar') {
def artifactPath = artifact.file
if (!embeddedJars.contains(artifactPath))
println "Adding Jar Artifact Dir into embeddedJars: ${artifactPath}"
embeddedJars.add(artifactPath)
} else {
throw new Exception("Unhandled Artifact of type ${artifact.type}")
}
}
}
if (dependencies.size() > 0) {
// Step: 2 -> Setup task dependencies here
// embedAssets -> generateReleaseAssets
generateReleaseAssets.dependsOn embedAssets
// embedLibraryResources -> packageReleaseResources
packageReleaseResources.dependsOn embedLibraryResources
// embedJniLibs -> bundleReleaseAar
bundleReleaseAar.dependsOn embedJniLibs
embedJniLibs.dependsOn transformNativeLibsWithSyncJniLibsForRelease
// Merging original manifest after processReleaseManifest in merged_manifests in build dir with library manifests and replacing original with this and aapt_friendly_merged_manifests
bundleReleaseAar.dependsOn embedManifests
embedManifests.dependsOn processReleaseManifest
compileReleaseJavaWithJavac.dependsOn generateRJava
bundleReleaseAar.dependsOn embedJavaJars
embedJavaJars.dependsOn compileReleaseJavaWithJavac
}
}
task embedAssets {
doLast {
println "Running FAT-AAR Task :embedAssets"
embeddedAarDirs.each { aarPath ->
// Merge Assets
println "Working on aarPath => ${aarPath}"
android.sourceSets.main.assets.srcDirs += file("$aarPath/assets")
}
}
}
task embedLibraryResources {
doLast {
println "Running FAT-AAR Task :embedLibraryResources ===> Fix This"
// def oldInputResourceSet = processReleaseJavaRes.inputSourceSets
// mergeResources.conventionMapping.map("inputResourceSets") {
// getMergedInputResourceSets(oldInputResourceSet)
// }
}
}
private List getMergedInputResourceSets(List inputResourceSet) {
//We need to do this trickery here since the class declared here and that used by the runtime
//are different and results in class cast error
def ResourceSetClass = inputResourceSet.get(0).class
List newInputResourceSet = new ArrayList(inputResourceSet)
println "getMergedInputResourceSets"
println embeddedAarDirs
embeddedAarDirs.each { aarPath ->
try {
println aarPath
def resname
if (gradleApiVersion >= 2.3f) {
def parentProject = project.rootProject.name.toString()
println "parent: "
println parentProject
def startIndex = aarPath.indexOf('/' + parentProject)
def endIndex = aarPath.indexOf('/build/')
println "start"
println startIndex
println "end"
println endIndex
if (startIndex < 1 || endIndex < 1)
return;
resname = aarPath.substring(startIndex, endIndex).replace('/', ':')
}
else
resname = (aarPath.split(exploded_aar_dir)[1]).replace('/', ':');
def rs = ResourceSetClass.newInstance([resname, true] as Object[])
rs.addSource(file("$aarPath/res"))
println "ResourceSet is " + rs
println resname
newInputResourceSet += rs
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
return newInputResourceSet
}
task embedJniLibs {
doLast {
println "Running FAT-AAR Task :embedJniLibs"
embeddedAarDirs.each { aarPath ->
println "======= Copying JNI from $aarPath/jni"
// Copy JNI Folders
copy {
from fileTree(dir: "$aarPath/jni")
into file("$build_dir/intermediates/jniLibs/release/")
into file("$build_dir/intermediates/library_and_local_jars_jni/release/")
}
}
}
}
task embedManifests {
doLast {
println "Running FAT-AAR Task :embedManifests"
ILogger mLogger = new MiLogger()
List libraryManifests = new ArrayList<>()
embeddedAarDirs.each { aarPath ->
println "Working on ${aarPath}"
File dependencyManifest = file("$aarPath/AndroidManifest.xml")
if (!libraryManifests.contains(aarPath) && dependencyManifest.exists()) {
println "Adding libraryManifestPath to list"
libraryManifests.add(dependencyManifest)
}
}
File reportFile = file("${build_dir}/embedManifestReport.txt")
println "reportFile path => ${reportFile.absolutePath}"
File origManifest = file("${build_dir}/intermediates/merged_manifests/release/processReleaseManifest/merged/AndroidManifest.xml")
println "origManifest path => ${origManifest.absolutePath}"
File copyManifest = file("${build_dir}/intermediates/merged_manifests/release/processReleaseManifest/merged/AndroidManifest.orig.xml")
println "copyManifest path => ${copyManifest.absolutePath}"
File aaptManifest = file("$manifest_aaapt_dir/AndroidManifest.xml")
println "aaptManifest path => ${aaptManifest.absolutePath}"
if(!origManifest.exists()) {
origManifest = file("./android/main/AndroidManifest.xml")
}
if(!origManifest.exists()) {
return;
}
copy {
from origManifest.parentFile
into copyManifest.parentFile
include origManifest.name
rename(origManifest.name, copyManifest.name)
}
try {
Invoker manifestMergerInvoker = ManifestMerger2.newMerger(copyManifest, mLogger, MergeType.APPLICATION)
manifestMergerInvoker.addLibraryManifests(libraryManifests.toArray(new File[libraryManifests.size()]))
// manifestMergerInvoker.setPlaceHolderValues(placeHolders)
manifestMergerInvoker.setMergeReportFile(reportFile);
MergingReport mergingReport = manifestMergerInvoker.merge();
mLogger.info("Merging result:" + mergingReport.getResult());
MergingReport.Result result = mergingReport.getResult();
switch (result) {
case MergingReport.Result.WARNING:
mergingReport.log(mLogger);
// fall through since these are just warnings.
case MergingReport.Result.SUCCESS:
XmlDocument xmlDocument = mergingReport.getMergedXmlDocument(MergingReport.MergedManifestKind.MERGED);
try {
String annotatedDocument = mergingReport.getActions().blame(xmlDocument);
mLogger.verbose(annotatedDocument);
} catch (Exception e) {
mLogger.error(e, "cannot print resulting xml");
}
save(xmlDocument, origManifest);
mLogger.info("Merged manifest saved to " + origManifest);
if (aaptManifest.exists()) {
//TODO :: Prateek :: visit method has different argument than XmlDocument
// PlaceholderEncoder.visit(xmlDocument);
save(xmlDocument, aaptManifest);
mLogger.info("Merged aapt safe manifest saved to " + aaptManifest);
}
break;
case MergingReport.Result.ERROR:
mergingReport.log(mLogger);
throw new RuntimeException(mergingReport.getReportString());
default:
throw new RuntimeException("Unhandled result type : " + mergingReport.getResult());
}
} catch (RuntimeException e) {
// Unacceptable error
e.printStackTrace()
throw new RuntimeException(e);
}
}
}
task generateRJava {
doLast {
println "Running FAT-AAR Task :generateRJava"
// Now generate the R.java file for each embedded dependency
def mainManifestFile = android.sourceSets.main.manifest.srcFile;
def libPackageName = "";
if(mainManifestFile.exists()) {
libPackageName = new XmlParser().parse(mainManifestFile).@package
}
println "Identified libPackageName as ${libPackageName}"
embeddedAarDirs.each { aarPath ->
println "Working on Aar Dir at path => ${aarPath}"
def manifestFile = file("$aarPath/AndroidManifest.xml");
if(!manifestFile.exists()) {
manifestFile = file("./android/main/AndroidManifest.xml");
}
if(manifestFile.exists()) {
def aarManifest = new XmlParser().parse(manifestFile);
def aarPackageName = aarManifest.@package
String packagePath = aarPackageName.replace('.', '/')
// Generate the R.java file and map to current project's R.java
// This will recreate the class file
def rTxt = file("$aarPath/R.txt")
def rMap = new ConfigObject()
if (rTxt.exists()) {
rTxt.eachLine {
line ->
//noinspection GroovyUnusedAssignment
def (type, subclass, name, value) = line.tokenize(' ')
rMap[subclass].putAt(name, type)
}
}
def sb = "package $aarPackageName;" << '\n' << '\n'
sb << 'public final class R {' << '\n'
rMap.each {
subclass, values ->
sb << " public static final class $subclass {" << '\n'
values.each {
name, type ->
sb << " public static $type $name = ${libPackageName}.R.${subclass}.${name};" << '\n'
}
sb << " }" << '\n'
}
sb << '}' << '\n'
mkdir("$generated_rsrc_dir/$packagePath")
file("$generated_rsrc_dir/$packagePath/R.java").write(sb.toString())
embeddedRClasses += "$packagePath/R.class"
embeddedRClasses += "$packagePath/R\$*.class"
println "Embedded R Classes => ${embeddedRClasses}"
}
}
}
}
task collectRClass {
doLast {
println "COLLECT R CLASS"
println "Deleting Base R2X Directory"
delete base_r2x_dir
println "Creating Base R2X Directory"
mkdir base_r2x_dir
println "Copying from: ${classs_release_dir} into ${base_r2x_dir}"
copy {
from classs_release_dir
include embeddedRClasses
into base_r2x_dir
}
}
}
task deleteRFolder(type: Delete, dependsOn: collectRClass) {
delete "${build_dir}/intermediates/packaged-classes/release/libs"
}
task embedRClass(type: org.gradle.jvm.tasks.Jar, dependsOn: deleteRFolder) {
doFirst {
println "EMBED R CLASS => Type: Jar"
mkdir "${build_dir}/intermediates/packaged-classes/release/libs"
}
baseName "rsource"
destinationDir file("${build_dir}/intermediates/packaged-classes/release/libs")
from base_r2x_dir
}
task embedJavaJars(dependsOn: embedRClass) {
doLast {
println "Running FAT-AAR Task :embedJavaJars"
embeddedAarDirs.each { aarPath ->
// Explode all classes.jar files to classes so that they can be proguarded
embeddedAarFiles.each {
artifact ->
FileTree aarFileTree = zipTree(artifact.file.getAbsolutePath());
def aarFile = aarFileTree.files.find { it.name.contains("classes.jar") }
copy {
from zipTree(aarFile)
into classs_release_dir
}
}
def embeddedJarPath = file("${aarPath}/libs");
println "embeddedJarPath => ${embeddedJarPath}"
if (embeddedJarPath.exists()) {
copy {
from embeddedJarPath
include "*.jar"
into file("${build_dir}/intermediates/packaged-classes/release/libs")
}
}
}
copy {
from embeddedJars
into file("${build_dir}/intermediates/packaged-classes/release/libs")
}
}
}
private void save(XmlDocument xmlDocument, File out) {
try {
Files.write(xmlDocument.prettyPrint(), out, Charsets.UTF_8);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
class MiLogger implements ILogger {
@Override
void error(
@com.android.annotations.Nullable Throwable t,
@com.android.annotations.Nullable String msgFormat, Object... args) {
System.err.println(String.format("========== ERROR : " + msgFormat, args))
if (t) t.printStackTrace(System.err)
}
@Override
void warning(@NonNull String msgFormat, Object... args) {
System.err.println(String.format("========== WARNING : " + msgFormat, args))
}
@Override
void info(@NonNull String msgFormat, Object... args) {
System.out.println(String.format("========== INFO : " + msgFormat, args))
}
@Override
void verbose(@NonNull String msgFormat, Object... args) {
// System.out.println(String.format("========== DEBUG : " + msgFormat, args))
}
}