Debian Codegraph @

compiler/src/main/java/android/databinding/annotationprocessor/ProcessDataBinding.java

raw
1 /*
2 * Copyright (C) 2015 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 package android.databinding.annotationprocessor;
18
19 import android.databinding.BindingBuildInfo;
20 import android.databinding.tool.CompilerChef;
21 import android.databinding.tool.processing.Scope;
22 import android.databinding.tool.reflection.ModelAnalyzer;
23 import android.databinding.tool.util.L;
24 import android.databinding.tool.util.Preconditions;
25 import android.databinding.tool.writer.AnnotationJavaFileWriter;
26 import android.databinding.tool.writer.BRWriter;
27 import android.databinding.tool.writer.JavaFileWriter;
28
29 import java.util.Arrays;
30 import java.util.List;
31 import java.util.Set;
32
33 import javax.annotation.processing.AbstractProcessor;
34 import javax.annotation.processing.ProcessingEnvironment;
35 import javax.annotation.processing.RoundEnvironment;
36 import javax.annotation.processing.SupportedAnnotationTypes;
37 import javax.lang.model.SourceVersion;
38 import javax.lang.model.element.TypeElement;
39 import javax.xml.bind.JAXBException;
40
41 @SupportedAnnotationTypes({
42 "android.databinding.BindingAdapter",
43 "android.databinding.Untaggable",
44 "android.databinding.BindingMethods",
45 "android.databinding.BindingConversion",
46 "android.databinding.BindingBuildInfo"}
47 )
48 /**
49 * Parent annotation processor that dispatches sub steps to ensure execution order.
50 * Use initProcessingSteps to add a new step.
51 */
52 public class ProcessDataBinding extends AbstractProcessor {
53 private List<ProcessingStep> mProcessingSteps;
54 @Override
55 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
56 if (mProcessingSteps == null) {
57 initProcessingSteps();
58 }
59 final BindingBuildInfo buildInfo = BuildInfoUtil.load(roundEnv);
60 if (buildInfo == null) {
61 return false;
62 }
63 boolean done = true;
64 for (ProcessingStep step : mProcessingSteps) {
65 try {
66 done = step.runStep(roundEnv, processingEnv, buildInfo) && done;
67 } catch (JAXBException e) {
68 L.e(e, "Exception while handling step %s", step);
69 }
70 }
71 if (roundEnv.processingOver()) {
72 for (ProcessingStep step : mProcessingSteps) {
73 step.onProcessingOver(roundEnv, processingEnv, buildInfo);
74 }
75 }
76 Scope.assertNoError();
77 return done;
78 }
79
80 @Override
81 public SourceVersion getSupportedSourceVersion() {
82 return SourceVersion.latest();
83 }
84
85 private void initProcessingSteps() {
86 final ProcessBindable processBindable = new ProcessBindable();
87 mProcessingSteps = Arrays.asList(
88 new ProcessMethodAdapters(),
89 new ProcessExpressions(),
90 processBindable
91 );
92 Callback dataBinderWriterCallback = new Callback() {
93 CompilerChef mChef;
94 BRWriter mBRWriter;
95 boolean mLibraryProject;
96 int mMinSdk;
97
98 @Override
99 public void onChefReady(CompilerChef chef, boolean libraryProject, int minSdk) {
100 Preconditions.checkNull(mChef, "Cannot set compiler chef twice");
101 chef.addBRVariables(processBindable);
102 mChef = chef;
103 mLibraryProject = libraryProject;
104 mMinSdk = minSdk;
105 considerWritingMapper();
106 mChef.writeDynamicUtil();
107 }
108
109 private void considerWritingMapper() {
110 if (mLibraryProject || mChef == null || mBRWriter == null) {
111 return;
112 }
113 mChef.writeDataBinderMapper(mMinSdk, mBRWriter);
114 }
115
116 @Override
117 public void onBrWriterReady(BRWriter brWriter) {
118 Preconditions.checkNull(mBRWriter, "Cannot set br writer twice");
119 mBRWriter = brWriter;
120 considerWritingMapper();
121 }
122 };
123 AnnotationJavaFileWriter javaFileWriter = new AnnotationJavaFileWriter(processingEnv);
124 for (ProcessingStep step : mProcessingSteps) {
125 step.mJavaFileWriter = javaFileWriter;
126 step.mCallback = dataBinderWriterCallback;
127 }
128 }
129
130 @Override
131 public synchronized void init(ProcessingEnvironment processingEnv) {
132 super.init(processingEnv);
133 ModelAnalyzer.setProcessingEnvironment(processingEnv);
134 }
135
136 /**
137 * To ensure execution order and binding build information, we use processing steps.
138 */
139 public abstract static class ProcessingStep {
140 private boolean mDone;
141 private JavaFileWriter mJavaFileWriter;
142 protected Callback mCallback;
143
144 protected JavaFileWriter getWriter() {
145 return mJavaFileWriter;
146 }
147
148 private boolean runStep(RoundEnvironment roundEnvironment,
149 ProcessingEnvironment processingEnvironment,
150 BindingBuildInfo buildInfo) throws JAXBException {
151 if (mDone) {
152 return true;
153 }
154 mDone = onHandleStep(roundEnvironment, processingEnvironment, buildInfo);
155 return mDone;
156 }
157
158 /**
159 * Invoked in each annotation processing step.
160 *
161 * @return True if it is done and should never be invoked again.
162 */
163 abstract public boolean onHandleStep(RoundEnvironment roundEnvironment,
164 ProcessingEnvironment processingEnvironment,
165 BindingBuildInfo buildInfo) throws JAXBException;
166
167 /**
168 * Invoked when processing is done. A good place to generate the output if the
169 * processor requires multiple steps.
170 */
171 abstract public void onProcessingOver(RoundEnvironment roundEnvironment,
172 ProcessingEnvironment processingEnvironment,
173 BindingBuildInfo buildInfo);
174 }
175
176 interface Callback {
177 void onChefReady(CompilerChef chef, boolean libraryProject, int minSdk);
178 void onBrWriterReady(BRWriter brWriter);
179 }
180 }