Java Logger.info方法代碼示例

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
/**
 * Wait for the Android Debug Bridge to return an initial device list.
 */
protected static void waitForInitialDeviceList(final AndroidDebugBridge androidDebugBridge, Logger logger) {
    if (!androidDebugBridge.hasInitialDeviceList()) {
        logger.info("Waiting for initial device list from the Android Debug Bridge");
        long limitTime = System.currentTimeMillis() + ADB_TIMEOUT_MS;
        while (!androidDebugBridge.hasInitialDeviceList() && (System.currentTimeMillis() < limitTime)) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException("Interrupted waiting for initial device list from Android Debug Bridge");
            }
        }
        if (!androidDebugBridge.hasInitialDeviceList()) {
            logger.error("Did not receive initial device list from the Android Debug Bridge.");
        }
    }
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
@Override
public void apply(final Project project) {
	Logger logger = project.getLogger();
	logger.info("applying jsweet plugin");

	if (!project.getPlugins().hasPlugin(JavaPlugin.class) && !project.getPlugins().hasPlugin(WarPlugin.class)) {
		logger.error("No java or war plugin detected. Enable java or war plugin.");
		throw new IllegalStateException("No java or war plugin detected. Enable java or war plugin.");
	}

	JSweetPluginExtension extension = project.getExtensions().create("jsweet", JSweetPluginExtension.class);

	JavaPluginConvention javaPluginConvention = project.getConvention().getPlugin(JavaPluginConvention.class);
	SourceSetContainer sourceSets = javaPluginConvention.getSourceSets();
	SourceSet mainSources = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);

	JSweetTranspileTask task = project.getTasks().create("jsweet", JSweetTranspileTask.class);
	task.setGroup("generate");
	task.dependsOn(JavaPlugin.COMPILE_JAVA_TASK_NAME);
	task.setConfiguration(extension);
	task.setSources(mainSources.getAllJava());
	task.setClasspath(mainSources.getCompileClasspath());
	
	JSweetCleanTask cleanTask = project.getTasks().create("jsweetClean", JSweetCleanTask.class);
	cleanTask.setConfiguration(extension);
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
private String getEv3Host() {
    Logger logger = getLogger();
    LejosEv3PluginExtension ev3 = getEv3PluginExtension();
    String host;
    if (ev3.discoverBrickEnabled()) {
        BrickInfo brick;
        try {
            brick =  BrickFinder.discover()[0];
        } catch (IOException e) {
            throw new GradleException("Error on discovering bricks", e);
        }
        logger.info("Found brick " + brick.getName() + " at " + brick.getIPAddress());
        host = brick.getIPAddress();
    } else {
        if (ev3.getHost() == null) {
            throw new GradleException("Please set property ev3.host");
        }
        host = ev3.getHost();
    }
    return host;
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
public void logHealth(DaemonHealthStats stats, Logger logger) {
    if (Boolean.getBoolean(HEALTH_MESSAGE_PROPERTY)) {
        logger.lifecycle(stats.getHealthInfo());
    } else {
        //the default
        logger.info(stats.getHealthInfo());
    }
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
private void addLink(Javadoc javadoc, String link) {
    MinimalJavadocOptions options = javadoc.getOptions();
    if (options instanceof StandardJavadocDocletOptions) {
        StandardJavadocDocletOptions docletOptions = (StandardJavadocDocletOptions) options;
        Logger logger = javadoc.getLogger();
        List<String> links = docletOptions.getLinks();

        if (!links.contains(link)) {
            logger.debug("Adding '{}' to {}", link, javadoc);
            links.add(link);
        } else {
            logger.info("Not adding '{}' to {} because it's already present", link, javadoc);
        }
    }
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
private boolean shouldBundlerRun(String requestedBundler, String currentRunningBundlerID, JavaFXGradlePluginExtension ext, final Logger logger, Map<String, ? super Object> params) {
    if( requestedBundler != null && !"ALL".equalsIgnoreCase(requestedBundler) && !requestedBundler.equalsIgnoreCase(currentRunningBundlerID) ){
        // this is not the specified bundler
        return false;
    }

    if( ext.isSkipJNLP() && "jnlp".equalsIgnoreCase(currentRunningBundlerID) ){
        logger.info("Skipped JNLP-bundling as requested.");
        return false;
    }

    boolean runBundler = true;
    // Workaround for native installer bundle not creating working executable native launcher
    // (this is a comeback of issue 124)
    // https://github.com/javafx-maven-plugin/javafx-maven-plugin/issues/205
    // do run application bundler and put the cfg-file to application resources
    if( System.getProperty("os.name").toLowerCase().startsWith("linux") ){
        if( workarounds.isWorkaroundForBug205Needed() ){
            // check if special conditions for this are met (not jnlp, but not linux.app too, because another workaround already works)
            if( !"jnlp".equalsIgnoreCase(requestedBundler) && !"linux.app".equalsIgnoreCase(requestedBundler) && "linux.app".equalsIgnoreCase(currentRunningBundlerID) ){
                if( !ext.isSkipNativeLauncherWorkaround205() ){
                    logger.info("Detected linux application bundler ('linux.app') needs to run before installer bundlers are executed.");
                    runBundler = true;
                    params.put(CFG_WORKAROUND_MARKER, "true");
                } else {
                    logger.info("Skipped workaround for native linux installer bundlers.");
                }
            }
        }
    }
    return runBundler;
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
public static void downloadMcJson(LoomGradleExtension extension, Logger logger) throws IOException {
	if (!Constants.MINECRAFT_JSON.get(extension).exists()) {
		logger.lifecycle(":downloading minecraft json");
		FileUtils.copyURLToFile(new URL("https://launchermeta.mojang.com/mc/game/version_manifest.json"), Constants.VERSION_MANIFEST.get(extension));
		ManifestVersion mcManifest = new GsonBuilder().create().fromJson(FileUtils.readFileToString(Constants.VERSION_MANIFEST.get(extension), "UTF-8"), ManifestVersion.class);

		Optional<ManifestVersion.Versions> optionalVersion = mcManifest.versions.stream().filter(versions -> versions.id.equalsIgnoreCase(extension.version)).findFirst();
		if (optionalVersion.isPresent()) {
			FileUtils.copyURLToFile(new URL(optionalVersion.get().url), Constants.MINECRAFT_JSON.get(extension));
		} else {
			logger.info(":failed downloading minecraft json");
			throw new RuntimeException("Failed downloading Minecraft json");
		}
	}
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
@TaskAction
public void uninstall() throws DeviceException {
    final Logger logger = getLogger();
    final String applicationId = variant.getApplicationId();

    logger.info("Uninstalling app: {}", applicationId);

    final ILogger lifecycleLogger = new LoggerWrapper(getLogger(), LogLevel.LIFECYCLE);
    final DeviceProvider deviceProvider =
            new ConnectedDeviceProvider(getAdbExe(), lifecycleLogger);

    deviceProvider.init();
    final List<? extends DeviceConnector> devices = deviceProvider.getDevices();

    for (DeviceConnector device : devices) {
        device.uninstallPackage(applicationId, getTimeOutInMs(), getILogger());
        logger.lifecycle(
                "Uninstalling {} (from {}:{}) from device '{}' ({}).",
                applicationId, getProject().getName(),
                variant.getVariantConfiguration().getFullName(),
                device.getName(), device.getSerialNumber());
    }

    int n = devices.size();
    logger.quiet("Uninstalled {} from {} device{}.",
            applicationId, n, n == 1 ? "" : "s");

}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
@TaskAction
public void createJavaFilesFromSQL() {
	final Project project = getProject();
	final Gradle gradle = project.getGradle();
	gradle.addListener(this);
	final Logger logger = getLogger();
	logger.info(
		"Creating Java files from SQL files in '%s' and writing them to '%s'...",
		sourceDirectory,
		destinationDirectory
	);
	final File output = project.file(destinationDirectory);
	final FileTree files = project.files(sourceDirectory).getAsFileTree();
	if (files.isEmpty()) {
		logger.info("There are no files to be processed!");
	}
	files.visit(details -> {
		if (details.isDirectory()) {
			return;
		}
		TargetAPI api = defaultApi;
		final String fileName = details.getName();
		final List<String> parts = Splitter.on('.').splitToList(fileName);
		final int indexOfLastPart = parts.size() - 1;
		if (indexOfLastPart == 0) {
			return;
		}
		final String extension = parts.get(indexOfLastPart);
		if ("sql".equalsIgnoreCase(extension) == false) {
			return;
		}
		if (parts.size() > 2) {
			final int indexOfSecondLastPart = indexOfLastPart - 1;
			api = TargetAPI.valueOf(parts.get(indexOfSecondLastPart).toUpperCase());
		}
		final String className = parts.get(0);
		final RelativePath relative = details.getRelativePath();
		logger.info("Creating Java file from '%s'...", relative);
		final Path sqlFile = details.getFile().toPath();
		final Path javaFile = relative.replaceLastName(className + ".java").getFile(output).toPath();
		final String path = details.getPath();
		final String namespace = path.substring(0, path.lastIndexOf('/')).replace('/', '.');
		try {
			JavaClassWriter
				.newBuilder()
				.setTargetAPI(api)
				.setNamespace(namespace)
				.setClassName(className)
				.setReader(sqlFile)
				.setWriter(javaFile)
				.writeClass();
		} catch (IOException exception) {
			throw new RuntimeException(exception);
		}
	});
}
 

import org.gradle.api.logging.Logger; //導入方法依賴的package包/類
private void applyWorkaroundsAfterBundling(String currentRunningBundlerID, final Logger logger, JavaFXGradlePluginExtension ext, String appName, Map<String, ? super Object> params, Project project) {
    // Workaround for "Native package for Ubuntu doesn't work"
    // https://github.com/javafx-maven-plugin/javafx-maven-plugin/issues/124
    // real bug: linux-launcher from oracle-jdk starting from 1.8.0u40 logic to determine .cfg-filename
    if( workarounds.isWorkaroundForBug124Needed() ){
        if( "linux.app".equals(currentRunningBundlerID) ){
            logger.info("Applying workaround for oracle-jdk-bug since 1.8.0u40 regarding native linux launcher(s).");
            if( !ext.isSkipNativeLauncherWorkaround124() ){
                List<NativeLauncher> nativeLaunchers = new ArrayList<>();

                // bugfix for #24 "NullPointerException on linux without secondary launchers"
                Optional.ofNullable(ext.getSecondaryLaunchers()).ifPresent(launchers -> {
                    nativeLaunchers.addAll(launchers.stream().map(launcherMap -> getNativeLauncher(launcherMap)).collect(Collectors.toList()));
                });

                workarounds.applyWorkaround124(appName, nativeLaunchers);
                // only apply workaround for issue 205 when having workaround for issue 124 active
                if( Boolean.parseBoolean(String.valueOf(params.get(CFG_WORKAROUND_MARKER))) && !Boolean.parseBoolean((String) params.get(CFG_WORKAROUND_DONE_MARKER)) ){
                    logger.info("Preparing workaround for oracle-jdk-bug since 1.8.0u40 regarding native linux launcher(s) inside native linux installers.");
                    workarounds.applyWorkaround205(appName, nativeLaunchers, params);
                    params.put(CFG_WORKAROUND_DONE_MARKER, "true");
                }
            } else {
                logger.info("Skipped workaround for native linux launcher(s).");
            }
        }
    }

    if( "jnlp".equals(currentRunningBundlerID) ){
        if( workarounds.isWorkaroundForBug182Needed() ){
            // Workaround for "JNLP-generation: path for dependency-lib on windows with backslash"
            // https://github.com/javafx-maven-plugin/javafx-maven-plugin/issues/182
            // jnlp-bundler uses RelativeFileSet, and generates system-dependent dividers (\ on windows, / on others)
            logger.info("Applying workaround for oracle-jdk-bug since 1.8.0u60 regarding jar-path inside generated JNLP-files.");
            if( !ext.isSkipJNLPRessourcePathWorkaround182() ){
                workarounds.fixPathsInsideJNLPFiles();
            } else {
                logger.info("Skipped workaround for jar-paths jar-path inside generated JNLP-files.");
            }
        }

        // Do sign generated jar-files by calling the packager (this might change in the future,
        // hopefully when oracle reworked the process inside the JNLP-bundler)
        // https://github.com/javafx-maven-plugin/javafx-maven-plugin/issues/185
        if( workarounds.isWorkaroundForBug185Needed(params) ){
            logger.info("Signing jar-files referenced inside generated JNLP-files.");
            if( !ext.isSkipSigningJarFilesJNLP185() ){
                // JavaFX signing using BLOB method will get dropped on JDK 9: "blob signing is going away in JDK9. "
                // https://bugs.openjdk.java.net/browse/JDK-8088866?focusedCommentId=13889898#comment-13889898
                if( !ext.isNoBlobSigning() ){
                    logger.info("Signing jar-files using BLOB method.");
                    signJarFilesUsingBlobSigning(project, ext);
                } else {
                    logger.info("Signing jar-files using jarsigner.");
                    signJarFiles(project, ext);
                }
                workarounds.applyWorkaround185(ext.isSkipSizeRecalculationForJNLP185());
            } else {
                logger.info("Skipped signing jar-files referenced inside JNLP-files.");
            }
        }
    }
}