How to use

BaseExtension

in

com.android.build.gradle

  @Override
  public void apply(Project project) {
    WMRouterExtension extension = project.getExtensions()
        .create(Const.NAME, WMRouterExtension.class);

    WMRouterLogger.info("register transform");
    project.getExtensions().findByType(BaseExtension.class)
        .registerTransform(new WMRouterTransform());

    project.afterEvaluate(p -> WMRouterLogger.setConfig(extension));
  }
}

@Override
public String getTargetCompatibility() {
 return JvmTarget.javaVersion(
   getAndroidExtension().getCompileOptions().getTargetCompatibility());
}

@Override
public LintOptions getLintOptions() {
 return getAndroidExtension().getLintOptions();
}

private void configureEtaSourceSetConvention() {
  androidExtension.getSourceSets().all(sourceSet -> {
      project.getLogger().debug("Creating EtaSourceSet for source set " + sourceSet);
      final DefaultEtaSourceSet etaSourceSet =
        project.getObjects().newInstance
        (DefaultEtaSourceSet.class, null, ETA_SOURCE_SET_NAME,
         ((DefaultAndroidSourceSet) sourceSet).getDisplayName(),
         sourceDirectorySetFactory);
      ExtensionHelper.createConvention
        (sourceSet, ETA_SOURCE_SET_DSL_NAME, etaSourceSet);
      ExtensionHelper.createConvention(sourceSet, "eta", etaSourceSet);
      etaSourceSet.getEta().srcDir("src/" + sourceSet.getName() + "/eta");
    });
}

  public static List<File> getAndroidSDKClasspath(BaseExtension extension) {
    return extension.getBootClasspath();
  }
}

getAndroidExtension().getDefaultConfig().getVectorDrawables().getUseSupportLibrary();

private static void setupBridge(Project project) {
  AndroidDebugBridge.initIfNeeded(false);
  String adbPath = ((BaseExtension)project.getExtensions().getByName("android")).getAdbExecutable().getAbsolutePath();
  bridge = AndroidDebugBridge.createBridge(adbPath, false);
}

public void createConfigurationForVariant() {
  ConfigurationContainer configurations = project.getConfigurations();
  extension.getSourceSets().all(androidSourceSet -> {
    if (!androidSourceSet.getName().startsWith(TEST)) { // don't support unit test
      Configuration configuration = configurations.maybeCreate(sourceSetToConfigurationName(androidSourceSet.getName()));

    "-d", output.getAbsolutePath(),
    "-classpath", Joiner.on(File.pathSeparator).join(classpathFiles),
    "-bootclasspath", Joiner.on(File.pathSeparator).join(androidExtension.getBootClasspath())
);

  @Override
  public void execute(Project project) {
    BaseExtension android = null;
    if (project.getPlugins().hasPlugin(LibraryPlugin.class)) {
      android = project.getExtensions().getByType(LibraryExtension.class);
    } else if (project.getPlugins().hasPlugin(AppPlugin.class)) {
      android = project.getExtensions().getByType(AppExtension.class);
    } else if (project.getPlugins().hasPlugin(TestPlugin.class)) {
      android = project.getExtensions().getByType(TestExtension.class);
    }
    if (android != null) {
      System.err.println("Hacking project " + project.getName());
      useHackedAndroidJar(android);
      android.registerTransform(new ReflectionAccessorTransform());
      android.registerTransform(new IncludeWrapperTransform());
    } else {
      System.err.println("Skipping project " + project.getName());
    }
  }
});

VariantResource variantResource = new VariantResource(getVariant(),
    files, factory);
variantResource.init(invocation, global.android().getBootClasspath(), getCaptConfiguration());
InternalCache internalCache = new InternalCache(singleFactory.newProvider(new File(files.variantRoot(), "core"))
    , global);

@Override
public String getSourceCompatibility() {
 return JvmTarget.javaVersion(
   getAndroidExtension().getCompileOptions().getSourceCompatibility());
}

@Override
public void apply(Project project) {
  project.getPlugins().matching(p -> p instanceof AppPlugin || p instanceof LibraryPlugin)
      .all(c -> {
        BaseExtension baseExtension = (BaseExtension) project.getExtensions().getByName("android");
        project.getExtensions().create(NAME, GradleCaptExtension.class, project.container(CaptPluginExtension.class));
        VariantManager variantManager = new VariantManager(createGlobalResource(project, baseExtension),
            baseExtension, project);
        // callCreate configurations for separate variant
        variantManager.createConfigurationForVariant();
        CaptTransform captTransform = new CaptTransform(variantManager);
        baseExtension.registerTransform(captTransform);
      });
}

@Override
protected void configurePlugin() {
  getProject().getDependencies().add(CONFIGURATION, "org.aspectj:aspectjrt:" + ASPECTJ_VERSION);
  getProject().getDependencies().add(CONFIGURATION, "com.quanturium.bouquet:bouquet-runtime:" + BOUQUET_VERSION);
  getProject().getDependencies().add(CONFIGURATION, "com.quanturium.bouquet:bouquet-runtime-android:" + BOUQUET_VERSION);
  BaseExtension androidExtension = (BaseExtension) getProject().getExtensions().getByName("android");
  if (!((BouquetExtension) getProject().getExtensions().getByName(BOUQUET_EXTENSION)).isEnabled()) {
    getProject().getLogger().debug("Skipping weaving. Bouquet is not enabled");
    return;
  }
  AspectJAndroidTransform aspectJAndroidTransform = new AspectJAndroidTransform(getProject(), androidExtension);
  androidExtension.registerTransform(aspectJAndroidTransform);
  // Add variants that we want to weave
  if (getProjectType() == ProjectType.ANDROID_APP) {
    ((AppExtension) androidExtension).getApplicationVariants().all(applicationVariant -> {
      if (applicationVariant.getBuildType().isDebuggable()) {
        aspectJAndroidTransform.addVariant(applicationVariant);
      }
    });
  } else if (getProjectType() == ProjectType.ANDROID_LIBRARY) {
    ((LibraryExtension) androidExtension).getLibraryVariants().all(libraryVariant -> {
      if (libraryVariant.getBuildType().isDebuggable()) {
        aspectJAndroidTransform.addVariant(libraryVariant);
      }
    });
  }
}