Java tutorial
/* * 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 com.google.common.base.Preconditions; import com.android.build.gradle.AppExtension; import com.android.build.gradle.BaseExtension; import com.android.build.gradle.LibraryExtension; import com.android.build.gradle.api.ApplicationVariant; import com.android.build.gradle.api.LibraryVariant; import com.android.build.gradle.api.TestVariant; import com.android.build.gradle.internal.api.ApplicationVariantImpl; import com.android.build.gradle.internal.api.LibraryVariantImpl; import com.android.build.gradle.internal.api.TestVariantImpl; import com.android.build.gradle.internal.core.GradleVariantConfiguration; import com.android.build.gradle.internal.variant.ApplicationVariantData; import com.android.build.gradle.internal.variant.BaseVariantData; import com.android.build.gradle.internal.variant.LibraryVariantData; import com.android.build.gradle.internal.variant.TestVariantData; import com.android.build.gradle.tasks.ProcessAndroidResources; import com.android.builder.model.ApiVersion; import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.exception.ExceptionUtils; import org.gradle.api.Action; import org.gradle.api.Plugin; import org.gradle.api.Project; import org.gradle.api.Task; import org.gradle.api.logging.LogLevel; import org.gradle.api.logging.Logger; import org.gradle.api.plugins.ExtraPropertiesExtension; import org.gradle.api.tasks.bundling.Jar; import org.gradle.api.tasks.compile.AbstractCompile; import android.databinding.tool.processing.ScopedException; import android.databinding.tool.util.L; import android.databinding.tool.writer.JavaFileWriter; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Field; import java.util.Arrays; import java.util.List; import javax.tools.Diagnostic; import javax.xml.bind.JAXBException; public class DataBinderPlugin implements Plugin<Project> { private static final String INVOKED_FROM_IDE_PROPERTY = "android.injected.invoked.from.ide"; private static final String PRINT_ENCODED_ERRORS_PROPERTY = "android.databinding.injected.print.encoded.errors"; private Logger logger; private boolean printEncodedErrors = false; 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"); logD("Asked to write to " + canonicalName + ". outputting to:" + f.getAbsolutePath()); //noinspection ResultOfMethodCallIgnored f.getParentFile().mkdirs(); FileOutputStream fos = null; try { fos = new FileOutputStream(f); IOUtils.write(contents, fos); } catch (IOException e) { logE(e, "cannot write file " + f.getAbsolutePath()); } finally { IOUtils.closeQuietly(fos); } } } private boolean safeGetBooleanProperty(Project project, String property) { boolean hasProperty = project.hasProperty(property); if (!hasProperty) { return false; } try { if (Boolean.parseBoolean(String.valueOf(project.getProperties().get(property)))) { return true; } } catch (Throwable t) { L.w("unable to read property %s", project); } return false; } private boolean resolvePrintEncodedErrors(Project project) { return safeGetBooleanProperty(project, INVOKED_FROM_IDE_PROPERTY) || safeGetBooleanProperty(project, PRINT_ENCODED_ERRORS_PROPERTY); } @Override public void apply(Project project) { if (project == null) { return; } setupLogger(project); String myVersion = readMyVersion(); logD("data binding plugin version is %s", myVersion); if (StringUtils.isEmpty(myVersion)) { throw new IllegalStateException("cannot read version of the plugin :/"); } printEncodedErrors = resolvePrintEncodedErrors(project); ScopedException.encodeOutput(printEncodedErrors); project.getDependencies().add("compile", "com.android.databinding:library:" + myVersion); boolean addAdapters = true; if (project.hasProperty("ext")) { Object ext = project.getProperties().get("ext"); if (ext instanceof ExtraPropertiesExtension) { ExtraPropertiesExtension propExt = (ExtraPropertiesExtension) ext; if (propExt.has("addDataBindingAdapters")) { addAdapters = Boolean.valueOf(String.valueOf(propExt.get("addDataBindingAdapters"))); } } } if (addAdapters) { project.getDependencies().add("compile", "com.android.databinding:adapters:" + myVersion); } project.getDependencies().add("provided", "com.android.databinding:compiler:" + myVersion); project.afterEvaluate(new Action<Project>() { @Override public void execute(Project project) { try { createXmlProcessor(project); } catch (Throwable t) { logE(t, "failed to setup data binding"); } } }); } private void setupLogger(Project project) { logger = project.getLogger(); L.setClient(new L.Client() { @Override public void printMessage(Diagnostic.Kind kind, String message) { if (kind == Diagnostic.Kind.ERROR) { logE(null, message); } else { logD(message); } } }); } String readMyVersion() { try { InputStream stream = getClass().getResourceAsStream("/data_binding_build_info"); try { return IOUtils.toString(stream, "utf-8").trim(); } finally { IOUtils.closeQuietly(stream); } } catch (IOException exception) { logE(exception, "Cannot read data binding version"); } return null; } private void createXmlProcessor(Project project) throws NoSuchFieldException, IllegalAccessException { L.d("creating xml processor for " + project); Object androidExt = project.getExtensions().getByName("android"); if (!(androidExt instanceof BaseExtension)) { return; } if (androidExt instanceof AppExtension) { createXmlProcessorForApp(project, (AppExtension) androidExt); } else if (androidExt instanceof LibraryExtension) { createXmlProcessorForLibrary(project, (LibraryExtension) androidExt); } else { logE(new UnsupportedOperationException("cannot understand android ext"), "unsupported android extension. What is it? %s", androidExt); } } private void createXmlProcessorForLibrary(Project project, LibraryExtension lib) throws NoSuchFieldException, IllegalAccessException { File sdkDir = lib.getSdkDirectory(); L.d("create xml processor for " + lib); for (TestVariant variant : lib.getTestVariants()) { logD("test variant %s. dir name %s", variant, variant.getDirName()); BaseVariantData variantData = getVariantData(variant); attachXmlProcessor(project, variantData, sdkDir, false);//tests extend apk variant } for (LibraryVariant variant : lib.getLibraryVariants()) { logD("library variant %s. dir name %s", variant, variant.getDirName()); BaseVariantData variantData = getVariantData(variant); attachXmlProcessor(project, variantData, sdkDir, true); } } private void createXmlProcessorForApp(Project project, AppExtension appExt) throws NoSuchFieldException, IllegalAccessException { L.d("create xml processor for " + appExt); File sdkDir = appExt.getSdkDirectory(); for (TestVariant testVariant : appExt.getTestVariants()) { TestVariantData variantData = getVariantData(testVariant); attachXmlProcessor(project, variantData, sdkDir, false); } for (ApplicationVariant appVariant : appExt.getApplicationVariants()) { ApplicationVariantData variantData = getVariantData(appVariant); attachXmlProcessor(project, variantData, sdkDir, false); } } private LibraryVariantData getVariantData(LibraryVariant variant) throws NoSuchFieldException, IllegalAccessException { Field field = LibraryVariantImpl.class.getDeclaredField("variantData"); field.setAccessible(true); return (LibraryVariantData) field.get(variant); } private TestVariantData getVariantData(TestVariant variant) throws IllegalAccessException, NoSuchFieldException { Field field = TestVariantImpl.class.getDeclaredField("variantData"); field.setAccessible(true); return (TestVariantData) field.get(variant); } private ApplicationVariantData getVariantData(ApplicationVariant variant) throws IllegalAccessException, NoSuchFieldException { Field field = ApplicationVariantImpl.class.getDeclaredField("variantData"); field.setAccessible(true); return (ApplicationVariantData) field.get(variant); } private void attachXmlProcessor(Project project, final BaseVariantData variantData, final File sdkDir, final Boolean isLibrary) { final GradleVariantConfiguration configuration = variantData.getVariantConfiguration(); final ApiVersion minSdkVersion = configuration.getMinSdkVersion(); ProcessAndroidResources generateRTask = variantData.generateRClassTask; final String packageName = generateRTask.getPackageForR(); String fullName = configuration.getFullName(); List<File> resourceFolders = Arrays.asList(variantData.mergeResourcesTask.getOutputDir()); final File codeGenTargetFolder = new File( project.getBuildDir() + "/data-binding-info/" + configuration.getDirName()); String writerOutBase = codeGenTargetFolder.getAbsolutePath(); JavaFileWriter fileWriter = new GradleFileWriter(writerOutBase); final LayoutXmlProcessor xmlProcessor = new LayoutXmlProcessor(packageName, resourceFolders, fileWriter, minSdkVersion.getApiLevel(), isLibrary); final ProcessAndroidResources processResTask = generateRTask; final File xmlOutDir = new File(project.getBuildDir() + "/layout-info/" + configuration.getDirName()); final File generatedClassListOut = isLibrary ? new File(xmlOutDir, "_generated.txt") : null; logD("xml output for %s is %s", variantData, xmlOutDir); String layoutTaskName = "dataBindingLayouts" + StringUtils.capitalize(processResTask.getName()); String infoClassTaskName = "dataBindingInfoClass" + StringUtils.capitalize(processResTask.getName()); final DataBindingProcessLayoutsTask[] processLayoutsTasks = new DataBindingProcessLayoutsTask[1]; project.getTasks().create(layoutTaskName, DataBindingProcessLayoutsTask.class, new Action<DataBindingProcessLayoutsTask>() { @Override public void execute(final DataBindingProcessLayoutsTask task) { processLayoutsTasks[0] = task; task.setXmlProcessor(xmlProcessor); task.setSdkDir(sdkDir); task.setXmlOutFolder(xmlOutDir); task.setMinSdk(minSdkVersion.getApiLevel()); logD("TASK adding dependency on %s for %s", task, processResTask); processResTask.dependsOn(task); processResTask.getInputs().dir(xmlOutDir); for (Object dep : processResTask.getDependsOn()) { if (dep == task) { continue; } logD("adding dependency on %s for %s", dep, task); task.dependsOn(dep); } processResTask.doLast(new Action<Task>() { @Override public void execute(Task unused) { try { task.writeLayoutXmls(); } catch (JAXBException e) { // gradle sometimes fails to resolve JAXBException. // We get stack trace manually to ensure we have the log logE(e, "cannot write layout xmls %s", ExceptionUtils.getStackTrace(e)); } } }); } }); final DataBindingProcessLayoutsTask processLayoutsTask = processLayoutsTasks[0]; project.getTasks().create(infoClassTaskName, DataBindingExportInfoTask.class, new Action<DataBindingExportInfoTask>() { @Override public void execute(DataBindingExportInfoTask task) { task.dependsOn(processLayoutsTask); task.dependsOn(processResTask); task.setXmlProcessor(xmlProcessor); task.setSdkDir(sdkDir); task.setXmlOutFolder(xmlOutDir); task.setExportClassListTo(generatedClassListOut); task.setPrintEncodedErrors(printEncodedErrors); task.setEnableDebugLogs(logger.isEnabled(LogLevel.DEBUG)); variantData.registerJavaGeneratingTask(task, codeGenTargetFolder); } }); String packageJarTaskName = "package" + StringUtils.capitalize(fullName) + "Jar"; final Task packageTask = project.getTasks().findByName(packageJarTaskName); if (packageTask instanceof Jar) { String removeGeneratedTaskName = "dataBindingExcludeGeneratedFrom" + StringUtils.capitalize(packageTask.getName()); if (project.getTasks().findByName(removeGeneratedTaskName) == null) { final AbstractCompile javaCompileTask = variantData.javacTask; Preconditions.checkNotNull(javaCompileTask); project.getTasks().create(removeGeneratedTaskName, DataBindingExcludeGeneratedTask.class, new Action<DataBindingExcludeGeneratedTask>() { @Override public void execute(DataBindingExcludeGeneratedTask task) { packageTask.dependsOn(task); task.dependsOn(javaCompileTask); task.setAppPackage(packageName); task.setInfoClassQualifiedName(xmlProcessor.getInfoClassFullName()); task.setPackageTask((Jar) packageTask); task.setLibrary(isLibrary); task.setGeneratedClassListFile(generatedClassListOut); } }); } } } private void logD(String s, Object... args) { logger.info(formatLog(s, args)); } private void logE(Throwable t, String s, Object... args) { logger.error(formatLog(s, args), t); } private String formatLog(String s, Object... args) { return "[data binding plugin]: " + String.format(s, args); } }