Merge branch 'javafx' of https://github.com/huanghongxun/HMCL into javafx

HMCL/src/main/java/org/jackhuang/hmcl/game/LauncherHelper.java

@@ -181,6 +181,7 @@ public final class LauncherHelper {
         if (java == null) {
             Controllers.dialog(Launcher.i18n("launch.wrong_javadir"), Launcher.i18n("message.error"), MessageBox.ERROR_MESSAGE, onAccept);
             setting.setJava(null);
+            setting.setDefaultJavaPath(null);
             java = JavaVersion.fromCurrentEnvironment();
             flag = true;
         }

HMCL/src/main/java/org/jackhuang/hmcl/setting/VersionSetting.java

@@ -26,7 +26,9 @@ import org.jackhuang.hmcl.util.*;
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.Type;
+import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 /**
  *
@@ -87,6 +89,20 @@ public final class VersionSetting {
         javaProperty.set(java);
     }
 
+    private final ImmediateStringProperty defaultJavaPathProperty = new ImmediateStringProperty(this, "defaultJavaPath", "");
+
+    /**
+     * Path to Java executable, or null if user customizes java directory.
+     * It's used to determine which JRE to use when multiple JREs match the selected Java version.
+     */
+    public String getDefaultJavaPath() {
+        return defaultJavaPathProperty.get();
+    }
+
+    public void setDefaultJavaPath(String defaultJavaPath) {
+        defaultJavaPathProperty.set(defaultJavaPath);
+    }
+
     private final ImmediateStringProperty javaDirProperty = new ImmediateStringProperty(this, "javaDir", "");
 
     public ImmediateStringProperty javaDirProperty() {
@@ -444,12 +460,18 @@ public final class VersionSetting {
                 return null; // Custom Java Directory not found,
             }
         } else if (StringUtils.isNotBlank(getJava())) {
-            JavaVersion c = JavaVersion.getJREs().get(getJava());
+            List<JavaVersion> matchedJava = JavaVersion.getJREs().stream()
-            if (c == null) {
+                    .filter(java -> java.getVersion().equals(getJava()))
+                    .collect(Collectors.toList());
+            if (matchedJava.isEmpty()) {
                 setJava("Default");
                 return JavaVersion.fromCurrentEnvironment();
-            } else
+            } else {
-                return c;
+                return matchedJava.stream()
+                        .filter(java -> java.getBinary().toString().equals(getDefaultJavaPath()))
+                        .findFirst()
+                        .orElse(matchedJava.get(0));
+            }
         } else throw new Error();
     }
 
@@ -535,6 +557,7 @@ public final class VersionSetting {
             obj.addProperty("gameDir", src.getGameDir());
             obj.addProperty("launcherVisibility", src.getLauncherVisibility().ordinal());
             obj.addProperty("gameDirType", src.getGameDirType().ordinal());
+            obj.addProperty("defaultJavaPath", src.getDefaultJavaPath());
 
             return obj;
         }
@@ -571,6 +594,7 @@ public final class VersionSetting {
             vs.setShowLogs(Optional.ofNullable(obj.get("showLogs")).map(JsonElement::getAsBoolean).orElse(false));
             vs.setLauncherVisibility(LauncherVisibility.values()[Optional.ofNullable(obj.get("launcherVisibility")).map(JsonElement::getAsInt).orElse(1)]);
             vs.setGameDirType(EnumGameDirectory.values()[Optional.ofNullable(obj.get("gameDirType")).map(JsonElement::getAsInt).orElse(0)]);
+            vs.setDefaultJavaPath(Optional.ofNullable(obj.get("defaultJavaPath")).map(JsonElement::getAsString).orElse(null));
 
             return vs;
         }

HMCL/src/main/java/org/jackhuang/hmcl/ui/VersionSettingsController.java

@@ -84,7 +84,7 @@ public final class VersionSettingsController {
 
         FXUtils.smoothScrolling(scroll);
 
-        Task.of(variables -> variables.set("list", JavaVersion.getJREs().values().stream().map(javaVersion ->
+        Task.of(variables -> variables.set("list", JavaVersion.getJREs().stream().map(javaVersion ->
                 javaItem.createChildren(javaVersion.getVersion(), javaVersion.getBinary().getAbsolutePath(), javaVersion)
         ).collect(Collectors.toList()))).subscribe(Schedulers.javafx(), variables ->
                 javaItem.loadChildren(variables.<Collection<Node>>get("list"))
@@ -165,8 +165,11 @@ public final class VersionSettingsController {
         javaItem.setToggleSelectedListener(newValue -> {
             if (javaItem.isCustomToggle(newValue)) {
                 versionSetting.setJava("Custom");
+                versionSetting.setDefaultJavaPath(null);
             } else {
-                versionSetting.setJava(((JavaVersion) newValue.getUserData()).getVersion());
+                JavaVersion java = (JavaVersion) newValue.getUserData();
+                versionSetting.setJava(java.getVersion());
+                versionSetting.setDefaultJavaPath(java.getBinary().toString());
             }
         });
 

HMCLCore/src/main/java/org/jackhuang/hmcl/util/JavaVersion.java

@@ -18,10 +18,17 @@
 package org.jackhuang.hmcl.util;
 
 import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.*;
 import java.util.concurrent.CountDownLatch;
+import java.util.logging.Level;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Represents a Java installation.
@@ -69,7 +76,7 @@ public final class JavaVersion implements Serializable {
         return version;
     }
 
-    private static final Pattern REGEX = Pattern.compile("java version \"(?<version>(.*?))\"");
+    private static final Pattern REGEX = Pattern.compile("version \"(?<version>(.*?))\"");
 
     public static final int UNKNOWN = -1;
     public static final int JAVA_5 = 50;
@@ -155,10 +162,10 @@ public final class JavaVersion implements Serializable {
             Platform.PLATFORM
     );
 
-    private static Map<String, JavaVersion> JAVAS;
+    private static List<JavaVersion> JAVAS;
     private static final CountDownLatch LATCH = new CountDownLatch(1);
 
-    public static Map<String, JavaVersion> getJREs() throws InterruptedException {
+    public static List<JavaVersion> getJREs() throws InterruptedException {
         if (JAVAS != null)
             return JAVAS;
         LATCH.await();
@@ -168,13 +175,14 @@ public final class JavaVersion implements Serializable {
     public static synchronized void initialize() throws IOException {
         if (JAVAS != null)
             throw new IllegalStateException("JavaVersions have already been initialized.");
-        HashMap<String, JavaVersion> temp = new HashMap<>();
-        temp.put(THIS_JAVA.getVersion(), THIS_JAVA);
         List<JavaVersion> javaVersions;
         switch (OperatingSystem.CURRENT_OS) {
             case WINDOWS:
                 javaVersions = queryWindows();
                 break;
+            case LINUX:
+                javaVersions = queryLinux();
+                break;
             case OSX:
                 javaVersions = queryMacintosh();
                 break;
@@ -182,12 +190,31 @@ public final class JavaVersion implements Serializable {
                 javaVersions = Collections.emptyList();
                 break;
         }
-        for (JavaVersion v : javaVersions)
+        JAVAS = Collections.unmodifiableList(javaVersions);
-            temp.put(v.getVersion(), v);
-        JAVAS = Collections.unmodifiableMap(temp);
         LATCH.countDown();
     }
 
+    private static List<JavaVersion> queryLinux() throws IOException {
+        Path jvmDir = Paths.get("/usr/lib/jvm");
+        if (Files.isDirectory(jvmDir)) {
+            return Files.list(jvmDir)
+                    .filter(dir -> Files.isDirectory(dir, LinkOption.NOFOLLOW_LINKS))
+                    .map(dir -> dir.resolve("bin/java"))
+                    .filter(Files::isExecutable)
+                    .flatMap(executable -> {
+                        try {
+                            return Stream.of(fromExecutable(executable.toFile()));
+                        } catch (IOException e) {
+                            Logging.LOG.log(Level.WARNING, "Couldn't determine java " + executable, e);
+                            return Stream.empty();
+                        }
+                    })
+                    .collect(Collectors.toList());
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
     private static List<JavaVersion> queryMacintosh() throws IOException {
         LinkedList<JavaVersion> res = new LinkedList<>();