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
|
// Copyright 2018 The Bazel Authors. All rights reserved.
//
// 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.
package com.google.devtools.build.lib.rules.android;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.RuleContext;
import com.google.devtools.build.lib.packages.RuleClass.ConfiguredTargetFactory.RuleErrorException;
import com.google.devtools.build.lib.rules.android.AndroidConfiguration.AndroidAaptVersion;
import javax.annotation.Nullable;
/**
* Processed Android data (assets, resources, and manifest) returned from resource processing.
*
* <p>In libraries, data is parsed, merged, and then validated. For top-level targets like
* android_binary, however, most of these steps happen in a single monolithic action. The only thing
* the monolithic action doesn't do is generate an R.class file for the resources. When combined
* with such a file, this object should contain the same data as the results of the individual
* actions.
*
* <p>In general, the individual actions should be used, as they are decoupled and designed to allow
* parallelized processing of a dependency tree of android_library targets. The monolithic action
* should only be used as part of building the data into a final APK that can become part of a
* produce android_binary or other top-level APK.
*/
public class ProcessedAndroidData {
private final ParsedAndroidResources resources;
private final MergedAndroidAssets assets;
private final ProcessedAndroidManifest manifest;
private final Artifact rTxt;
private final Artifact sourceJar;
private final Artifact apk;
@Nullable private final Artifact dataBindingInfoZip;
private final ResourceDependencies resourceDeps;
static ProcessedAndroidData of(
ParsedAndroidResources resources,
MergedAndroidAssets assets,
ProcessedAndroidManifest manifest,
Artifact rTxt,
Artifact sourceJar,
Artifact apk,
@Nullable Artifact dataBindingInfoZip,
ResourceDependencies resourceDeps) {
return new ProcessedAndroidData(
resources, assets, manifest, rTxt, sourceJar, apk, dataBindingInfoZip, resourceDeps);
}
private ProcessedAndroidData(
ParsedAndroidResources resources,
MergedAndroidAssets assets,
ProcessedAndroidManifest manifest,
Artifact rTxt,
Artifact sourceJar,
Artifact apk,
@Nullable Artifact dataBindingInfoZip,
ResourceDependencies resourceDeps) {
this.resources = resources;
this.assets = assets;
this.manifest = manifest;
this.rTxt = rTxt;
this.sourceJar = sourceJar;
this.apk = apk;
this.dataBindingInfoZip = dataBindingInfoZip;
this.resourceDeps = resourceDeps;
}
/**
* Gets the fully processed resources from this class.
*
* <p>Registers an action to run R class generation, the last step needed in resource processing.
* Returns the fully processed resources.
*/
public ValidatedAndroidResources generateRClass(RuleContext ruleContext)
throws RuleErrorException, InterruptedException {
return new RClassGeneratorActionBuilder(ruleContext)
.targetAaptVersion(AndroidAaptVersion.chooseTargetAaptVersion(ruleContext))
.withDependencies(resourceDeps)
.setClassJarOut(
ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_RESOURCES_CLASS_JAR))
.build(this);
}
/**
* Returns fully processed resources. The R class generator action will not be registered.
*
* @param rClassJar an artifact containing the resource class jar for these resources. An action
* to generate it must be registered elsewhere.
*/
ValidatedAndroidResources toValidatedResources(Artifact rClassJar) {
// When assets and resources are processed together, they are both merged into the same zip
Artifact mergedResources = assets.getMergedAssets();
// Since parts of both merging and validation were already done in combined resource processing,
// we need to build containers for both here.
MergedAndroidResources merged =
MergedAndroidResources.of(
resources, mergedResources, rClassJar, dataBindingInfoZip, resourceDeps, manifest);
// Combined resource processing does not produce aapt2 artifacts; they're nulled out
return ValidatedAndroidResources.of(merged, rTxt, sourceJar, apk, null, null, null);
}
public MergedAndroidAssets getAssets() {
return assets;
}
public ProcessedAndroidManifest getManifest() {
return manifest;
}
public Artifact getRTxt() {
return rTxt;
}
}
|
