Debian Codegraph @

compiler/src/main/java/android/databinding/tool/reflection/ModelAnalyzer.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 package android.databinding.tool.reflection;
17
18 import android.databinding.tool.reflection.annotation.AnnotationAnalyzer;
19 import android.databinding.tool.util.L;
20 import android.databinding.tool.util.Preconditions;
21 import android.databinding.tool.util.StringUtils;
22
23 import java.util.HashMap;
24 import java.util.Map;
25
26 import javax.annotation.processing.ProcessingEnvironment;
27
28 /**
29 * This is the base class for several implementations of something that
30 * acts like a ClassLoader. Different implementations work with the Annotation
31 * Processor, ClassLoader, and an Android Studio plugin.
32 */
33 public abstract class ModelAnalyzer {
34
35 public static final String[] LIST_CLASS_NAMES = {
36 "java.util.List",
37 "android.util.SparseArray",
38 "android.util.SparseBooleanArray",
39 "android.util.SparseIntArray",
40 "android.util.SparseLongArray",
41 "android.util.LongSparseArray",
42 "android.support.v4.util.LongSparseArray",
43 };
44
45 public static final String MAP_CLASS_NAME = "java.util.Map";
46
47 public static final String STRING_CLASS_NAME = "java.lang.String";
48
49 public static final String OBJECT_CLASS_NAME = "java.lang.Object";
50
51 public static final String OBSERVABLE_CLASS_NAME = "android.databinding.Observable";
52
53 public static final String OBSERVABLE_LIST_CLASS_NAME = "android.databinding.ObservableList";
54
55 public static final String OBSERVABLE_MAP_CLASS_NAME = "android.databinding.ObservableMap";
56
57 public static final String[] OBSERVABLE_FIELDS = {
58 "android.databinding.ObservableBoolean",
59 "android.databinding.ObservableByte",
60 "android.databinding.ObservableChar",
61 "android.databinding.ObservableShort",
62 "android.databinding.ObservableInt",
63 "android.databinding.ObservableLong",
64 "android.databinding.ObservableFloat",
65 "android.databinding.ObservableDouble",
66 "android.databinding.ObservableField",
67 "android.databinding.ObservableParcelable",
68 };
69
70 public static final String VIEW_DATA_BINDING =
71 "android.databinding.ViewDataBinding";
72
73 public static final String VIEW_STUB_CLASS_NAME = "android.view.ViewStub";
74
75 private ModelClass[] mListTypes;
76 private ModelClass mMapType;
77 private ModelClass mStringType;
78 private ModelClass mObjectType;
79 private ModelClass mObservableType;
80 private ModelClass mObservableListType;
81 private ModelClass mObservableMapType;
82 private ModelClass[] mObservableFieldTypes;
83 private ModelClass mViewBindingType;
84 private ModelClass mViewStubType;
85
86 private static ModelAnalyzer sAnalyzer;
87 private final Map<String, InjectedClass> mInjectedClasses =
88 new HashMap<String, InjectedClass>();
89
90 protected void setInstance(ModelAnalyzer analyzer) {
91 sAnalyzer = analyzer;
92 }
93
94 public ModelClass findCommonParentOf(ModelClass modelClass1, ModelClass modelClass2) {
95 return findCommonParentOf(modelClass1, modelClass2, true);
96 }
97
98 public ModelClass findCommonParentOf(ModelClass modelClass1, ModelClass modelClass2,
99 boolean failOnError) {
100 ModelClass curr = modelClass1;
101 while (curr != null && !curr.isAssignableFrom(modelClass2)) {
102 curr = curr.getSuperclass();
103 }
104 if (curr == null) {
105 if (modelClass1.isObject() && modelClass2.isInterface()) {
106 return modelClass1;
107 } else if (modelClass2.isObject() && modelClass1.isInterface()) {
108 return modelClass2;
109 }
110
111 ModelClass primitive1 = modelClass1.unbox();
112 ModelClass primitive2 = modelClass2.unbox();
113 if (!modelClass1.equals(primitive1) || !modelClass2.equals(primitive2)) {
114 return findCommonParentOf(primitive1, primitive2, failOnError);
115 }
116 }
117 if (failOnError) {
118 Preconditions.checkNotNull(curr,
119 "must be able to find a common parent for " + modelClass1 + " and "
120 + modelClass2);
121 }
122 return curr;
123 }
124
125 public abstract ModelClass loadPrimitive(String className);
126
127 public static ModelAnalyzer getInstance() {
128 return sAnalyzer;
129 }
130
131 public static void setProcessingEnvironment(ProcessingEnvironment processingEnvironment) {
132 if (sAnalyzer != null) {
133 throw new IllegalStateException("processing env is already created, you cannot "
134 + "change class loader after that");
135 }
136 L.d("setting processing env to %s", processingEnvironment);
137 sAnalyzer = new AnnotationAnalyzer(processingEnvironment);
138 }
139
140 /**
141 * Takes a raw className (potentially w/ generics and arrays) and expands definitions using
142 * the import statements.
143 * <p>
144 * For instance, this allows user to define variables
145 * <variable type="User" name="user"/>
146 * if they previously imported User.
147 * <import name="com.example.User"/>
148 */
149 public String applyImports(String className, Map<String, String> imports) {
150 className = className.trim();
151 int numDimensions = 0;
152 String generic = null;
153 // handle array
154 while (className.endsWith("[]")) {
155 numDimensions++;
156 className = className.substring(0, className.length() - 2);
157 }
158 // handle generics
159 final int lastCharIndex = className.length() - 1;
160 if ('>' == className.charAt(lastCharIndex)) {
161 // has generic.
162 int open = className.indexOf('<');
163 if (open == -1) {
164 L.e("un-matching generic syntax for %s", className);
165 return className;
166 }
167 generic = applyImports(className.substring(open + 1, lastCharIndex), imports);
168 className = className.substring(0, open);
169 }
170 int dotIndex = className.indexOf('.');
171 final String qualifier;
172 final String rest;
173 if (dotIndex == -1) {
174 qualifier = className;
175 rest = null;
176 } else {
177 qualifier = className.substring(0, dotIndex);
178 rest = className.substring(dotIndex); // includes dot
179 }
180 final String expandedQualifier = imports.get(qualifier);
181 String result;
182 if (expandedQualifier != null) {
183 result = rest == null ? expandedQualifier : expandedQualifier + rest;
184 } else {
185 result = className; // no change
186 }
187 // now append back dimension and generics
188 if (generic != null) {
189 result = result + "<" + applyImports(generic, imports) + ">";
190 }
191 while (numDimensions-- > 0) {
192 result = result + "[]";
193 }
194 return result;
195 }
196
197 public String getDefaultValue(String className) {
198 if ("int".equals(className)) {
199 return "0";
200 }
201 if ("short".equals(className)) {
202 return "0";
203 }
204 if ("long".equals(className)) {
205 return "0L";
206 }
207 if ("float".equals(className)) {
208 return "0f";
209 }
210 if ("double".equals(className)) {
211 return "0.0";
212 }
213 if ("boolean".equals(className)) {
214 return "false";
215 }
216 if ("char".equals(className)) {
217 return "'\\u0000'";
218 }
219 if ("byte".equals(className)) {
220 return "0";
221 }
222 return "null";
223 }
224
225 public final ModelClass findClass(String className, Map<String, String> imports) {
226 if (mInjectedClasses.containsKey(className)) {
227 return mInjectedClasses.get(className);
228 }
229 return findClassInternal(className, imports);
230 }
231
232 public abstract ModelClass findClassInternal(String className, Map<String, String> imports);
233
234 public abstract ModelClass findClass(Class classType);
235
236 public abstract TypeUtil createTypeUtil();
237
238 public ModelClass injectClass(InjectedClass injectedClass) {
239 mInjectedClasses.put(injectedClass.getCanonicalName(), injectedClass);
240 return injectedClass;
241 }
242
243 public ModelClass injectViewDataBinding(String className, Map<String, String> variables,
244 Map<String, String> fields) {
245 InjectedClass injectedClass = new InjectedClass(className,
246 ModelAnalyzer.VIEW_DATA_BINDING);
247
248 if (fields != null) {
249 for (String name : fields.keySet()) {
250 String type = fields.get(name);
251 injectedClass.addField(new InjectedField(name, type));
252 }
253 }
254 if (variables != null) {
255 for (String name : variables.keySet()) {
256 String type = variables.get(name);
257 String capName = StringUtils.capitalize(name);
258 String setName = "set" + capName;
259 String getName = "get" + capName;
260 injectedClass.addMethod(new InjectedMethod(injectedClass, false, getName, type));
261 injectedClass.addMethod(new InjectedMethod(injectedClass, false, setName, "void",
262 type));
263 }
264 }
265 mInjectedClasses.put(className, injectedClass);
266 return injectedClass;
267 }
268
269 ModelClass[] getListTypes() {
270 if (mListTypes == null) {
271 mListTypes = new ModelClass[LIST_CLASS_NAMES.length];
272 for (int i = 0; i < mListTypes.length; i++) {
273 final ModelClass modelClass = findClass(LIST_CLASS_NAMES[i], null);
274 if (modelClass != null) {
275 mListTypes[i] = modelClass.erasure();
276 }
277 }
278 }
279 return mListTypes;
280 }
281
282 public ModelClass getMapType() {
283 if (mMapType == null) {
284 mMapType = loadClassErasure(MAP_CLASS_NAME);
285 }
286 return mMapType;
287 }
288
289 ModelClass getStringType() {
290 if (mStringType == null) {
291 mStringType = findClass(STRING_CLASS_NAME, null);
292 }
293 return mStringType;
294 }
295
296 ModelClass getObjectType() {
297 if (mObjectType == null) {
298 mObjectType = findClass(OBJECT_CLASS_NAME, null);
299 }
300 return mObjectType;
301 }
302
303 ModelClass getObservableType() {
304 if (mObservableType == null) {
305 mObservableType = findClass(OBSERVABLE_CLASS_NAME, null);
306 }
307 return mObservableType;
308 }
309
310 ModelClass getObservableListType() {
311 if (mObservableListType == null) {
312 mObservableListType = loadClassErasure(OBSERVABLE_LIST_CLASS_NAME);
313 }
314 return mObservableListType;
315 }
316
317 ModelClass getObservableMapType() {
318 if (mObservableMapType == null) {
319 mObservableMapType = loadClassErasure(OBSERVABLE_MAP_CLASS_NAME);
320 }
321 return mObservableMapType;
322 }
323
324 ModelClass getViewDataBindingType() {
325 if (mViewBindingType == null) {
326 mViewBindingType = findClass(VIEW_DATA_BINDING, null);
327 }
328 return mViewBindingType;
329 }
330
331 protected ModelClass[] getObservableFieldTypes() {
332 if (mObservableFieldTypes == null) {
333 mObservableFieldTypes = new ModelClass[OBSERVABLE_FIELDS.length];
334 for (int i = 0; i < OBSERVABLE_FIELDS.length; i++) {
335 mObservableFieldTypes[i] = loadClassErasure(OBSERVABLE_FIELDS[i]);
336 }
337 }
338 return mObservableFieldTypes;
339 }
340
341 ModelClass getViewStubType() {
342 if (mViewStubType == null) {
343 mViewStubType = findClass(VIEW_STUB_CLASS_NAME, null);
344 }
345 return mViewStubType;
346 }
347
348 private ModelClass loadClassErasure(String className) {
349 return findClass(className, null).erasure();
350 }
351 }