Debian Codegraph @

compilerCommon/src/main/java/android/databinding/tool/LayoutXmlProcessor.java

raw
1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
12 */
13
14 package android.databinding.tool;
15
16 import com.google.common.escape.Escaper;
17
18 import org.apache.commons.io.FileUtils;
19 import org.xml.sax.SAXException;
20
21 import android.databinding.BindingBuildInfo;
22 import android.databinding.tool.store.LayoutFileParser;
23 import android.databinding.tool.store.ResourceBundle;
24 import android.databinding.tool.util.L;
25 import android.databinding.tool.util.Preconditions;
26 import android.databinding.tool.util.SourceCodeEscapers;
27 import android.databinding.tool.writer.JavaFileWriter;
28
29 import java.io.File;
30 import java.io.FilenameFilter;
31 import java.io.IOException;
32 import java.net.URI;
33 import java.util.ArrayList;
34 import java.util.List;
35 import java.util.UUID;
36
37 import javax.xml.bind.JAXBException;
38 import javax.xml.parsers.ParserConfigurationException;
39 import javax.xml.xpath.XPathExpressionException;
40
41 /**
42 * Processes the layout XML, stripping the binding attributes and elements
43 * and writes the information into an annotated class file for the annotation
44 * processor to work with.
45 */
46 public class LayoutXmlProcessor {
47 // hardcoded in baseAdapters
48 public static final String RESOURCE_BUNDLE_PACKAGE = "android.databinding.layouts";
49 public static final String CLASS_NAME = "DataBindingInfo";
50 private final JavaFileWriter mFileWriter;
51 private final ResourceBundle mResourceBundle;
52 private final int mMinSdk;
53
54 private boolean mProcessingComplete;
55 private boolean mWritten;
56 private final boolean mIsLibrary;
57 private final String mBuildId = UUID.randomUUID().toString();
58 private final OriginalFileLookup mOriginalFileLookup;
59
60 public LayoutXmlProcessor(String applicationPackage,
61 JavaFileWriter fileWriter, int minSdk, boolean isLibrary,
62 OriginalFileLookup originalFileLookup) {
63 mFileWriter = fileWriter;
64 mResourceBundle = new ResourceBundle(applicationPackage);
65 mMinSdk = minSdk;
66 mIsLibrary = isLibrary;
67 mOriginalFileLookup = originalFileLookup;
68 }
69
70 private static void processIncrementalInputFiles(ResourceInput input,
71 ProcessFileCallback callback)
72 throws IOException, ParserConfigurationException, XPathExpressionException,
73 SAXException {
74 processExistingIncrementalFiles(input.getRootInputFolder(), input.getAdded(), callback);
75 processExistingIncrementalFiles(input.getRootInputFolder(), input.getChanged(), callback);
76 processRemovedIncrementalFiles(input.getRootInputFolder(), input.getRemoved(), callback);
77 }
78
79 private static void processExistingIncrementalFiles(File inputRoot, List<File> files,
80 ProcessFileCallback callback)
81 throws IOException, XPathExpressionException, SAXException,
82 ParserConfigurationException {
83 for (File file : files) {
84 File parent = file.getParentFile();
85 if (inputRoot.equals(parent)) {
86 callback.processOtherRootFile(file);
87 } else if (layoutFolderFilter.accept(parent, parent.getName())) {
88 callback.processLayoutFile(file);
89 } else {
90 callback.processOtherFile(parent, file);
91 }
92 }
93 }
94
95 private static void processRemovedIncrementalFiles(File inputRoot, List<File> files,
96 ProcessFileCallback callback)
97 throws IOException {
98 for (File file : files) {
99 File parent = file.getParentFile();
100 if (inputRoot.equals(parent)) {
101 callback.processRemovedOtherRootFile(file);
102 } else if (layoutFolderFilter.accept(parent, parent.getName())) {
103 callback.processRemovedLayoutFile(file);
104 } else {
105 callback.processRemovedOtherFile(parent, file);
106 }
107 }
108 }
109
110 private static void processAllInputFiles(ResourceInput input, ProcessFileCallback callback)
111 throws IOException, XPathExpressionException, SAXException,
112 ParserConfigurationException {
113 FileUtils.deleteDirectory(input.getRootOutputFolder());
114 Preconditions.check(input.getRootOutputFolder().mkdirs(), "out dir should be re-created");
115 Preconditions.check(input.getRootInputFolder().isDirectory(), "it must be a directory");
116 for (File firstLevel : input.getRootInputFolder().listFiles()) {
117 if (firstLevel.isDirectory()) {
118 if (layoutFolderFilter.accept(firstLevel, firstLevel.getName())) {
119 callback.processLayoutFolder(firstLevel);
120 for (File xmlFile : firstLevel.listFiles(xmlFileFilter)) {
121 callback.processLayoutFile(xmlFile);
122 }
123 } else {
124 callback.processOtherFolder(firstLevel);
125 for (File file : firstLevel.listFiles()) {
126 callback.processOtherFile(firstLevel, file);
127 }
128 }
129 } else {
130 callback.processOtherRootFile(firstLevel);
131 }
132
133 }
134 }
135
136 /**
137 * used by the studio plugin
138 */
139 public ResourceBundle getResourceBundle() {
140 return mResourceBundle;
141 }
142
143 public boolean processResources(final ResourceInput input)
144 throws ParserConfigurationException, SAXException, XPathExpressionException,
145 IOException {
146 if (mProcessingComplete) {
147 return false;
148 }
149 final LayoutFileParser layoutFileParser = new LayoutFileParser();
150 final URI inputRootUri = input.getRootInputFolder().toURI();
151 ProcessFileCallback callback = new ProcessFileCallback() {
152 private File convertToOutFile(File file) {
153 final String subPath = toSystemDependentPath(inputRootUri
154 .relativize(file.toURI()).getPath());
155 return new File(input.getRootOutputFolder(), subPath);
156 }
157 @Override
158 public void processLayoutFile(File file)
159 throws ParserConfigurationException, SAXException, XPathExpressionException,
160 IOException {
161 final File output = convertToOutFile(file);
162 final ResourceBundle.LayoutFileBundle bindingLayout = layoutFileParser
163 .parseXml(file, output, mResourceBundle.getAppPackage(), mOriginalFileLookup);
164 if (bindingLayout != null && !bindingLayout.isEmpty()) {
165 mResourceBundle.addLayoutBundle(bindingLayout);
166 }
167 }
168
169 @Override
170 public void processOtherFile(File parentFolder, File file) throws IOException {
171 final File outParent = convertToOutFile(parentFolder);
172 FileUtils.copyFile(file, new File(outParent, file.getName()));
173 }
174
175 @Override
176 public void processRemovedLayoutFile(File file) {
177 mResourceBundle.addRemovedFile(file);
178 final File out = convertToOutFile(file);
179 FileUtils.deleteQuietly(out);
180 }
181
182 @Override
183 public void processRemovedOtherFile(File parentFolder, File file) throws IOException {
184 final File outParent = convertToOutFile(parentFolder);
185 FileUtils.deleteQuietly(new File(outParent, file.getName()));
186 }
187
188 @Override
189 public void processOtherFolder(File folder) {
190 //noinspection ResultOfMethodCallIgnored
191 convertToOutFile(folder).mkdirs();
192 }
193
194 @Override
195 public void processLayoutFolder(File folder) {
196 //noinspection ResultOfMethodCallIgnored
197 convertToOutFile(folder).mkdirs();
198 }
199
200 @Override
201 public void processOtherRootFile(File file) throws IOException {
202 final File outFile = convertToOutFile(file);
203 if (file.isDirectory()) {
204 FileUtils.copyDirectory(file, outFile);
205 } else {
206 FileUtils.copyFile(file, outFile);
207 }
208 }
209
210 @Override
211 public void processRemovedOtherRootFile(File file) throws IOException {
212 final File outFile = convertToOutFile(file);
213 FileUtils.deleteQuietly(outFile);
214 }
215 };
216 if (input.isIncremental()) {
217 processIncrementalInputFiles(input, callback);
218 } else {
219 processAllInputFiles(input, callback);
220 }
221 mProcessingComplete = true;
222 return true;
223 }
224
225 public static String toSystemDependentPath(String path) {
226 if (File.separatorChar != '/') {
227 path = path.replace('/', File.separatorChar);
228 }
229 return path;
230 }
231
232 public void writeLayoutInfoFiles(File xmlOutDir) throws JAXBException {
233 if (mWritten) {
234 return;
235 }
236 for (List<ResourceBundle.LayoutFileBundle> layouts : mResourceBundle.getLayoutBundles()
237 .values()) {
238 for (ResourceBundle.LayoutFileBundle layout : layouts) {
239 writeXmlFile(xmlOutDir, layout);
240 }
241 }
242 for (File file : mResourceBundle.getRemovedFiles()) {
243 String exportFileName = generateExportFileName(file);
244 FileUtils.deleteQuietly(new File(xmlOutDir, exportFileName));
245 }
246 mWritten = true;
247 }
248
249 private void writeXmlFile(File xmlOutDir, ResourceBundle.LayoutFileBundle layout)
250 throws JAXBException {
251 String filename = generateExportFileName(layout);
252 mFileWriter.writeToFile(new File(xmlOutDir, filename), layout.toXML());
253 }
254
255 public String getInfoClassFullName() {
256 return RESOURCE_BUNDLE_PACKAGE + "." + CLASS_NAME;
257 }
258
259 /**
260 * Generates a string identifier that can uniquely identify the given layout bundle.
261 * This identifier can be used when we need to export data about this layout bundle.
262 */
263 private static String generateExportFileName(ResourceBundle.LayoutFileBundle layout) {
264 return generateExportFileName(layout.getFileName(), layout.getDirectory());
265 }
266
267 private static String generateExportFileName(File file) {
268 final String fileName = file.getName();
269 return generateExportFileName(fileName.substring(0, fileName.lastIndexOf('.')),
270 file.getParentFile().getName());
271 }
272
273 public static String generateExportFileName(String fileName, String dirName) {
274 return fileName + '-' + dirName + ".xml";
275 }
276
277 public static String exportLayoutNameFromInfoFileName(String infoFileName) {
278 return infoFileName.substring(0, infoFileName.indexOf('-'));
279 }
280
281 public void writeInfoClass(/*Nullable*/ File sdkDir, File xmlOutDir,
282 /*Nullable*/ File exportClassListTo) {
283 writeInfoClass(sdkDir, xmlOutDir, exportClassListTo, false, false);
284 }
285
286 public String getPackage() {
287 return mResourceBundle.getAppPackage();
288 }
289
290 public void writeInfoClass(/*Nullable*/ File sdkDir, File xmlOutDir, File exportClassListTo,
291 boolean enableDebugLogs, boolean printEncodedErrorLogs) {
292 Escaper javaEscaper = SourceCodeEscapers.javaCharEscaper();
293 final String sdkPath = sdkDir == null ? null : javaEscaper.escape(sdkDir.getAbsolutePath());
294 final Class annotation = BindingBuildInfo.class;
295 final String layoutInfoPath = javaEscaper.escape(xmlOutDir.getAbsolutePath());
296 final String exportClassListToPath = exportClassListTo == null ? "" :
297 javaEscaper.escape(exportClassListTo.getAbsolutePath());
298 String classString = "package " + RESOURCE_BUNDLE_PACKAGE + ";\n\n" +
299 "import " + annotation.getCanonicalName() + ";\n\n" +
300 "@" + annotation.getSimpleName() + "(buildId=\"" + mBuildId + "\", " +
301 "modulePackage=\"" + mResourceBundle.getAppPackage() + "\", " +
302 "sdkRoot=" + "\"" + (sdkPath == null ? "" : sdkPath) + "\"," +
303 "layoutInfoDir=\"" + layoutInfoPath + "\"," +
304 "exportClassListTo=\"" + exportClassListToPath + "\"," +
305 "isLibrary=" + mIsLibrary + "," +
306 "minSdk=" + mMinSdk + "," +
307 "enableDebugLogs=" + enableDebugLogs + "," +
308 "printEncodedError=" + printEncodedErrorLogs + ")\n" +
309 "public class " + CLASS_NAME + " {}\n";
310 mFileWriter.writeToFile(RESOURCE_BUNDLE_PACKAGE + "." + CLASS_NAME, classString);
311 }
312
313 private static final FilenameFilter layoutFolderFilter = new FilenameFilter() {
314 @Override
315 public boolean accept(File dir, String name) {
316 return name.startsWith("layout");
317 }
318 };
319
320 private static final FilenameFilter xmlFileFilter = new FilenameFilter() {
321 @Override
322 public boolean accept(File dir, String name) {
323 return name.toLowerCase().endsWith(".xml");
324 }
325 };
326
327 /**
328 * Helper interface that can find the original copy of a resource XML.
329 */
330 public interface OriginalFileLookup {
331
332 /**
333 * @param file The intermediate build file
334 * @return The original file or null if original File cannot be found.
335 */
336 File getOriginalFileFor(File file);
337 }
338
339 /**
340 * API agnostic class to get resource changes incrementally.
341 */
342 public static class ResourceInput {
343 private final boolean mIncremental;
344 private final File mRootInputFolder;
345 private final File mRootOutputFolder;
346
347 private List<File> mAdded = new ArrayList<File>();
348 private List<File> mRemoved = new ArrayList<File>();
349 private List<File> mChanged = new ArrayList<File>();
350
351 public ResourceInput(boolean incremental, File rootInputFolder, File rootOutputFolder) {
352 mIncremental = incremental;
353 mRootInputFolder = rootInputFolder;
354 mRootOutputFolder = rootOutputFolder;
355 }
356
357 public void added(File file) {
358 mAdded.add(file);
359 }
360 public void removed(File file) {
361 mRemoved.add(file);
362 }
363 public void changed(File file) {
364 mChanged.add(file);
365 }
366
367 public boolean shouldCopy() {
368 return !mRootInputFolder.equals(mRootOutputFolder);
369 }
370
371 List<File> getAdded() {
372 return mAdded;
373 }
374
375 List<File> getRemoved() {
376 return mRemoved;
377 }
378
379 List<File> getChanged() {
380 return mChanged;
381 }
382
383 File getRootInputFolder() {
384 return mRootInputFolder;
385 }
386
387 File getRootOutputFolder() {
388 return mRootOutputFolder;
389 }
390
391 public boolean isIncremental() {
392 return mIncremental;
393 }
394
395 @Override
396 public String toString() {
397 StringBuilder out = new StringBuilder();
398 out.append("ResourceInput{")
399 .append("mIncremental=").append(mIncremental)
400 .append(", mRootInputFolder=").append(mRootInputFolder)
401 .append(", mRootOutputFolder=").append(mRootOutputFolder);
402 logFiles(out, "added", mAdded);
403 logFiles(out, "removed", mRemoved);
404 logFiles(out, "changed", mChanged);
405 return out.toString();
406
407 }
408
409 private static void logFiles(StringBuilder out, String name, List<File> files) {
410 out.append("\n ").append(name);
411 for (File file : files) {
412 out.append("\n - ").append(file.getAbsolutePath());
413 }
414 }
415 }
416
417 private interface ProcessFileCallback {
418 void processLayoutFile(File file)
419 throws ParserConfigurationException, SAXException, XPathExpressionException,
420 IOException;
421 void processOtherFile(File parentFolder, File file) throws IOException;
422 void processRemovedLayoutFile(File file);
423 void processRemovedOtherFile(File parentFolder, File file) throws IOException;
424
425 void processOtherFolder(File folder);
426
427 void processLayoutFolder(File folder);
428
429 void processOtherRootFile(File file) throws IOException;
430
431 void processRemovedOtherRootFile(File file) throws IOException;
432 }
433 }