Java ProjectConnection.getModel方法代码示例

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
/**
 * Returns the {@link com.android.builder.model.AndroidProject} given the gradle project root.
 * Note that this works only single module projects (only one build.gradle)
 */
@Nullable
private static AndroidProject getAndroidProject(String projectPath) {
  File androidPlugin = new File(AndroidTestBase.getAndroidPluginHome());
  File projectDir = new File(androidPlugin, BASE_PATH + projectPath);
  GradleConnector connector = GradleConnector.newConnector();
  connector.forProjectDirectory(projectDir);
  connector.useDistribution(new DistributionLocator().getDistributionFor(GradleVersion.version("2.2.1")));

  AndroidProject model = null;
  ProjectConnection connection = connector.connect();
  try {
    model = connection.getModel(AndroidProject.class);
  } finally {
    connection.close();
  }

  return model;
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
private EclipseProject getGradleModel(final String absoluteTargetPath) {

        GradleConnector connector = GradleConnector.newConnector();
        File target = new File(absoluteTargetPath);
        connector.forProjectDirectory(target);
        ProjectConnection connection = null;
        EclipseProject eclipseProject = null;
        try {
            connection = connector.connect();

            eclipseProject = connection.getModel(EclipseProject.class);


        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return eclipseProject;
    }
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
static AndroidProject getAndroidProject(
    final File root, final org.gradle.tooling.model.GradleProject gradleProject) {
  String path = gradleProject.getPath();
  String name = path.substring(1);
  File childDir = new File(root, name);
  GradleConnector childConnector = GradleConnector.newConnector().forProjectDirectory(childDir);
  ProjectConnection childConnection = childConnector.connect();
  try {
    return childConnection.getModel(AndroidProject.class);
  } catch (Exception e) {
    return null;
  } finally {
    childConnection.close();
  }
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
@Override
public List<String> getValues(String attributeName) throws ValueStorageException {
    final java.io.File ioFolder = projectFolder.getVirtualFile().getIoFile();

    if (!isGradleProject(ioFolder)) {
        return unmodifiableList(emptyList());
    }

    final ProjectConnection projectConnection = projectManager.getProjectConnection(ioFolder);
    final GradleProject projectModel = projectConnection.getModel(GradleProject.class);
    final IdeaProject ideaProjectModel = projectConnection.getModel(IdeaProject.class);
    final BuildEnvironment buildEnvironmentModel = projectConnection.getModel(BuildEnvironment.class);

    try {

        switch (attributeName) {
            case PROJECT_TASKS_VAR:
                return getPublicTasks(projectModel);
            case PROJECT_BUILD_DIR_VAR:
                return unmodifiableList(singletonList(getBuildDirectory(projectModel)));
            case PROJECT_PATH_VAR:
                return unmodifiableList(singletonList(getPath(projectModel)));
            case PROJECT_BUILD_SCRIPT_VAR:
                return unmodifiableList(singletonList(getBuildScriptPath(projectModel)));
            case PROJECT_DESCRIPTION_VAR:
                return unmodifiableList(singletonList(getProjectDescription(projectModel)));
            case PROJECT_SOURCE_DIR_VAR:
                return getProjectSourceDirectories(ideaProjectModel, SOURCE);
            case PROJECT_TEST_DIR_VAR:
                return getProjectSourceDirectories(ideaProjectModel, TEST_SOURCE);
            case PROJECT_GRADLE_VERSION_VAR:
                return unmodifiableList(singletonList(getGradleVersion(buildEnvironmentModel)));
            default:
                return unmodifiableList(emptyList());
        }

    } finally {
        projectConnection.close();
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
public AndroidProject getModel(@NonNull File project) {
    // Configure the connector and create the connection
    GradleConnector connector = GradleConnector.newConnector();

    connector.forProjectDirectory(project);

    ProjectConnection connection = connector.connect();
    try {
        // Load the custom model for the project
        return connection.getModel(AndroidProject.class);
    } finally {
        connection.close();
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
/**
 * Return a list of all task names of the project.
 */
public List<String> getTaskList() {
    ProjectConnection connection = getProjectConnection();
    try {
        GradleProject project = connection.getModel(GradleProject.class);
        List<String> tasks = Lists.newArrayList();
        for (GradleTask gradleTask : project.getTasks()) {
            tasks.add(gradleTask.getName());
        }
        return tasks;
    } finally {
        connection.close();
    }

}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
private void generateGradleClasspath() {

            GradleConnector connector = GradleConnector.newConnector();
            File target = new File(targetDir);
            connector.forProjectDirectory(target);
            ProjectConnection connection = null;

            try {
                connection = connector.connect();

                EclipseProject eclipseProject = connection.getModel(EclipseProject.class);
                StringBuilder gradleClasspath = new StringBuilder();
                for (ExternalDependency externalDependency : eclipseProject.getClasspath()) {
                    if(gradleClasspath.toString().isEmpty()) {
                        gradleClasspath.append(externalDependency.getFile().getAbsolutePath());
                    } else {
                        gradleClasspath.append(File.pathSeparator + externalDependency.getFile().getAbsolutePath());
                    }
                }
                PrintWriter pw = null;
                try {
                    pw = new PrintWriter(new File(targetDir + File.separator + "tacoco.cp"));
                    pw.write(gradleClasspath.toString());
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
                pw.close();


            } finally {
                if (connection != null) {
                    connection.close();
                }
            }
        }
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
public void execute(ProjectConfigurationProvider provider, BasicGradleProject parent) throws Exception {
	DomainObjectSet<? extends BasicGradleProject> subprojects = null;
	File parentDir = provider.getConfigurationFile().getCanonicalFile().getParentFile();

	if (parent == null) {
		GradleConnector connector = GradleConnector.newConnector();

		connector.forProjectDirectory(parentDir);
		ProjectConnection connection = connector.connect();

		GradleBuild settings = connection.getModel(GradleBuild.class);
		subprojects = settings.getProjects();
	} else {
		subprojects = parent.getChildren();
	}
	Iterator<? extends BasicGradleProject> it = subprojects.iterator();
	String currentDir = parentDir.getCanonicalPath();
	List<String> modules = new LinkedList<String>();
	while (it.hasNext()) {
		BasicGradleProject current = it.next();
		File projectDir = current.getProjectDirectory().getCanonicalFile();
		if (!projectDir.getPath().equals(currentDir)) {
			modules.add(current.getName());
			ProjectConfigurationProvider moduleCfgProvider = provider
					.clone(new File(projectDir, "walkmod." + provider.getFileExtension()));

			execute(moduleCfgProvider, current);
		}

	}
	if (!modules.isEmpty()) {
		provider.addModules(modules);
	} else {
		provider.createConfig();
	}
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
/**
 * Get the gradle project model for a given project.
 * @param project
 * @return
 */
public static GradleProject getProjectModelForProject(IProject project) {
	ProjectConnection connection = null;
	try {
		connection = buildConnectionForProject(project.getLocation().toFile().getAbsoluteFile()).connect();
		return connection.getModel(GradleProject.class);
	} finally {
		connection.close();
	}
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
private GradleVersion determineTargetGradleVersion(ProjectConnection connection) {
    BuildEnvironment buildEnvironment = connection.getModel(BuildEnvironment.class);
    return GradleVersion.version(buildEnvironment.getGradle().getGradleVersion());
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
/**
 * Returns the current build environment.
 * @param connection the connection
 * @return the current environment
 * @since 0.5.2
 */
public static BuildEnvironment getEnvironment(ProjectConnection connection) {
    return connection.getModel(BuildEnvironment.class);
}