| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * 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 android.databinding.tool; |
| |
| import org.apache.commons.io.IOUtils; |
| |
| import android.databinding.tool.processing.Scope; |
| import android.databinding.tool.processing.ScopedException; |
| import android.databinding.tool.util.L; |
| import android.databinding.tool.util.Preconditions; |
| import android.databinding.tool.writer.JavaFileWriter; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Properties; |
| |
| |
| /** |
| * This class is used by Android Gradle plugin. |
| */ |
| @SuppressWarnings("unused") |
| public class DataBindingBuilder { |
| Versions mVersions; |
| private final static String EXCLUDE_PATTERN = "android/databinding/layouts/*.*"; |
| public String getCompilerVersion() { |
| return getVersions().compiler; |
| } |
| |
| public String getBaseLibraryVersion(String compilerVersion) { |
| return getVersions().baseLibrary; |
| } |
| |
| public String getLibraryVersion(String compilerVersion) { |
| return getVersions().extensions; |
| } |
| |
| public String getBaseAdaptersVersion(String compilerVersion) { |
| return getVersions().extensions; |
| } |
| |
| public void setPrintMachineReadableOutput(boolean machineReadableOutput) { |
| ScopedException.encodeOutput(machineReadableOutput); |
| } |
| |
| public boolean getPrintMachineReadableOutput() { |
| return ScopedException.issEncodeOutput(); |
| } |
| |
| public void setDebugLogEnabled(boolean enableDebugLogs) { |
| L.setDebugLog(enableDebugLogs); |
| } |
| |
| public boolean isDebugLogEnabled() { |
| return L.isDebugEnabled(); |
| } |
| |
| private Versions getVersions() { |
| if (mVersions != null) { |
| return mVersions; |
| } |
| try { |
| Properties props = new Properties(); |
| InputStream stream = getClass().getResourceAsStream("/data_binding_version_info.properties"); |
| try { |
| props.load(stream); |
| mVersions = new Versions(props); |
| } finally { |
| IOUtils.closeQuietly(stream); |
| } |
| } catch (IOException exception) { |
| L.e(exception, "Cannot read data binding version"); |
| } |
| return mVersions; |
| } |
| |
| /** |
| * Returns the list of classes that should be excluded from package task |
| * |
| * @param layoutXmlProcessor The LayoutXmlProcessor for this variant |
| * @param generatedClassListFile The location of the File into which data binding compiler wrote |
| * list of generated classes |
| * |
| * @return The list of classes to exclude. They are already in JNI format. |
| */ |
| public List<String> getJarExcludeList(LayoutXmlProcessor layoutXmlProcessor, |
| File generatedClassListFile) { |
| List<String> excludes = new ArrayList<String>(); |
| String appPkgAsClass = layoutXmlProcessor.getPackage().replace('.', '/'); |
| String infoClassAsClass = layoutXmlProcessor.getInfoClassFullName().replace('.', '/'); |
| |
| excludes.add(infoClassAsClass + ".class"); |
| excludes.add(EXCLUDE_PATTERN); |
| excludes.add(appPkgAsClass + "/BR.*"); |
| excludes.add("android/databinding/DynamicUtil.class"); |
| if (generatedClassListFile != null) { |
| List<String> generatedClasses = readGeneratedClasses(generatedClassListFile); |
| for (String klass : generatedClasses) { |
| excludes.add(klass.replace('.', '/') + ".class"); |
| } |
| } |
| Scope.assertNoError(); |
| return excludes; |
| } |
| |
| private List<String> readGeneratedClasses(File generatedClassListFile) { |
| Preconditions.checkNotNull(generatedClassListFile, "Data binding exclude generated task" |
| + " is not configured properly"); |
| Preconditions.check(generatedClassListFile.exists(), |
| "Generated class list does not exist %s", generatedClassListFile.getAbsolutePath()); |
| FileInputStream fis = null; |
| try { |
| fis = new FileInputStream(generatedClassListFile); |
| return IOUtils.readLines(fis); |
| } catch (FileNotFoundException e) { |
| L.e(e, "Unable to read generated class list from %s", |
| generatedClassListFile.getAbsoluteFile()); |
| } catch (IOException e) { |
| L.e(e, "Unexpected exception while reading %s", |
| generatedClassListFile.getAbsoluteFile()); |
| } finally { |
| IOUtils.closeQuietly(fis); |
| } |
| L.e("Could not read data binding generated class list"); |
| return null; |
| } |
| |
| public JavaFileWriter createJavaFileWriter(File outFolder) { |
| return new GradleFileWriter(outFolder.getAbsolutePath()); |
| } |
| |
| static class GradleFileWriter extends JavaFileWriter { |
| |
| private final String outputBase; |
| |
| public GradleFileWriter(String outputBase) { |
| this.outputBase = outputBase; |
| } |
| |
| @Override |
| public void writeToFile(String canonicalName, String contents) { |
| String asPath = canonicalName.replace('.', '/'); |
| File f = new File(outputBase + "/" + asPath + ".java"); |
| //noinspection ResultOfMethodCallIgnored |
| f.getParentFile().mkdirs(); |
| FileOutputStream fos = null; |
| try { |
| fos = new FileOutputStream(f); |
| IOUtils.write(contents, fos); |
| } catch (IOException e) { |
| L.e(e, "cannot write file " + f.getAbsolutePath()); |
| } finally { |
| IOUtils.closeQuietly(fos); |
| } |
| } |
| } |
| |
| private static class Versions { |
| final String compilerCommon; |
| final String compiler; |
| final String baseLibrary; |
| final String extensions; |
| |
| public Versions(Properties properties) { |
| compilerCommon = properties.getProperty("compilerCommon"); |
| compiler = properties.getProperty("compiler"); |
| baseLibrary = properties.getProperty("baseLibrary"); |
| extensions = properties.getProperty("extensions"); |
| Preconditions.checkNotNull(compilerCommon, "cannot read compiler common version"); |
| Preconditions.checkNotNull(compiler, "cannot read compiler version"); |
| Preconditions.checkNotNull(baseLibrary, "cannot read baseLibrary version"); |
| Preconditions.checkNotNull(extensions, "cannot read extensions version"); |
| } |
| } |
| } |