chore: restructure Platform

Author: skaldarnar

src/main/java/org/terasology/launcher/LauncherInitTask.java

@@ -12,6 +12,7 @@
 import org.slf4j.LoggerFactory;
 import org.terasology.launcher.game.GameManager;
 import org.terasology.launcher.model.LauncherVersion;
+import org.terasology.launcher.platform.UnsupportedPlatformException;
 import org.terasology.launcher.repositories.CombinedRepository;
 import org.terasology.launcher.settings.LauncherSettingsValidator;
 import org.terasology.launcher.settings.Settings;
@@ -24,7 +25,7 @@
 import org.terasology.launcher.util.LauncherDirectoryUtils;
 import org.terasology.launcher.util.LauncherManagedDirectory;
 import org.terasology.launcher.util.LauncherStartFailedException;
-import org.terasology.launcher.util.Platform;
+import org.terasology.launcher.platform.Platform;
 
 import java.io.IOException;
 import java.net.URI;
@@ -114,18 +115,17 @@ protected LauncherConfiguration call() {
                     releaseRepository);
         } catch (LauncherStartFailedException e) {
             logger.warn("Could not configure launcher.");
+        } catch (UnsupportedPlatformException e) {
+            logger.error("Unsupported OS or architecture: {}", e.getMessage());
         }
 
         return null;
     }
 
-    private Platform getPlatform() {
+    private Platform getPlatform() throws UnsupportedPlatformException {
         logger.trace("Init Platform...");
         updateMessage(I18N.getLabel("splash_checkOS"));
         final Platform platform = Platform.getPlatform();
-        if (!platform.isLinux() && !platform.isMac() && !platform.isWindows()) {
-            logger.warn("Detected unexpected platform: {}", platform);
-        }
         logger.debug("Platform: {}", platform);
         return platform;
     }

src/main/java/org/terasology/launcher/game/GameService.java

@@ -8,6 +8,7 @@
 import javafx.concurrent.Worker;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.terasology.launcher.platform.UnsupportedPlatformException;
 import org.terasology.launcher.settings.Settings;
 
 import java.io.IOException;
@@ -49,19 +50,20 @@ public class GameService extends Service<Boolean> {
 
     public GameService() {
         setExecutor(Executors.newSingleThreadExecutor(
-            new ThreadFactoryBuilder()
-                    .setNameFormat("GameService-%d")
-                    .setDaemon(true)
-                    .setUncaughtExceptionHandler(this::exceptionHandler)
-                    .build()
+                new ThreadFactoryBuilder()
+                        .setNameFormat("GameService-%d")
+                        .setDaemon(true)
+                        .setUncaughtExceptionHandler(this::exceptionHandler)
+                        .build()
         ));
     }
 
     /**
      * Start a new game process with these settings.
+     *
      * @param gameInstallation the directory under which we will find libs/Terasology.jar, also used as the process's
-     *     working directory
-     * @param settings supplies other settings relevant to configuring a process
+     *                     working directory
+     * @param settings     supplies other settings relevant to configuring a process
      */
     @SuppressWarnings("checkstyle:HiddenField")
     public void start(GameInstallation gameInstallation, Settings settings) {
@@ -115,7 +117,7 @@ public void restart() {
      * This class's configuration fields <em>must</em> be set before this is called.
      *
      * @throws com.google.common.base.VerifyException when fields are unset
-     * @throws RuntimeException when required files in the game directory are missing or inaccessible
+     * @throws RuntimeException                       when required files in the game directory are missing or inaccessible
      */
     @Override
     protected RunGameTask createTask() throws GameVersionNotSupportedException {
@@ -128,19 +130,23 @@ protected RunGameTask createTask() throws GameVersionNotSupportedException {
                     settings.userJavaParameters.get(),
                     settings.userGameParameters.get(),
                     settings.logLevel.get());
-        } catch (IOException e) {
+        } catch (IOException | UnsupportedPlatformException e) {
             throw new RuntimeException("Error using this as a game directory: " + gamePath, e);
         }
         return new RunGameTask(starter);
     }
 
-    /** After a task completes, reset to ready for the next. */
+    /**
+     * After a task completes, reset to ready for the next.
+     */
     @Override
     protected void succeeded() {
         reset();  // Ready to go again!
     }
 
-    /** Checks to see if the failure left any exceptions behind, then resets to ready. */
+    /**
+     * Checks to see if the failure left any exceptions behind, then resets to ready.
+     */
     @Override
     protected void failed() {
         // "Uncaught" exceptions from javafx's Task are actually caught and kept in a property,

src/main/java/org/terasology/launcher/game/GameStarter.java

@@ -7,8 +7,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.event.Level;
+import org.terasology.launcher.platform.UnsupportedPlatformException;
 import org.terasology.launcher.util.JavaHeapSize;
-import org.terasology.launcher.util.Platform;
+import org.terasology.launcher.platform.Platform;
 
 import java.io.IOException;
 import java.nio.file.Path;
@@ -38,7 +39,8 @@ final class GameStarter implements Callable<Process> {
      * @param logLevel          the minimum level of log events Terasology will include on its output stream to us
      */
     GameStarter(GameInstallation gameInstallation, Path gameDataDirectory, JavaHeapSize heapMin, JavaHeapSize heapMax,
-                List<String> javaParams, List<String> gameParams, Level logLevel) throws IOException, GameVersionNotSupportedException {
+                List<String> javaParams, List<String> gameParams, Level logLevel)
+            throws IOException, GameVersionNotSupportedException, UnsupportedPlatformException {
         Semver engineVersion = gameInstallation.getEngineVersion();
         var gamePath = gameInstallation.getPath();
 

src/main/java/org/terasology/launcher/platform/Arch.java

@@ -0,0 +1,10 @@
+// Copyright 2023 The Terasology Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+package org.terasology.launcher.platform;
+
+public enum Arch {
+    X64,
+    X86,
+    ARM64
+}

src/main/java/org/terasology/launcher/platform/OS.java

@@ -0,0 +1,10 @@
+// Copyright 2023 The Terasology Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+package org.terasology.launcher.platform;
+
+public enum OS {
+    WINDOWS,
+    MAC,
+    LINUX
+}

src/main/java/org/terasology/launcher/platform/Platform.java

@@ -0,0 +1,132 @@
+// Copyright 2023 The Terasology Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+package org.terasology.launcher.platform;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Sets;
+
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * A simplified representation of a computer platform as `os` and `arch`
+ */
+public final class Platform {
+
+    final private OS os;
+    final private Arch arch;
+
+    //TODO(skaldarnar): I'm not fully settled on how to model the Platform. I thought splitting this up into two enums
+    //  for OS and Architecture would help with more type-safe construction of these values, simplify comparison to
+    //  select the right JRE for a game, etc.
+    //
+    //  On the other hand, the set of supported platforms is so limited, and continuing on a non-supported platform
+    //  does not make much sense. So, maybe it is better to have a rather restrictive and explicit enum in the form of
+    //      WINDOWS_X64
+    //      LINUX_X64
+    //  I'm adding the architecture to this list, as I hope that we'll be able to support old Intel and new M1 Macs at
+    //  some point in the future, adding the following to the list:
+    //      MAC_X64
+    //      MAC_AARCH64
+    //  The biggest drawback of being super-strict here is that development on non-supported platforms becomes
+    //  impossible where it was just "not ideal" before.
+    public static final Set<Platform> SUPPORTED_PLATFORMS = Sets.newHashSet(
+            new Platform(OS.WINDOWS, Arch.X64),
+            new Platform(OS.LINUX, Arch.X64),
+            new Platform(OS.MAC, Arch.X64)
+    );
+
+    public Platform(OS os, Arch arch) {
+        this.os = os;
+        this.arch = arch;
+    }
+
+    /**
+     * @return the simplified operating system name as platform os
+     */
+    public String getOs() {
+        //TODO: change return type to OS
+        return os.name().toLowerCase(Locale.ENGLISH);
+    }
+
+    /**
+     * @return the simplified operating system architecture as platform arch
+     */
+    public Arch getArch() {
+        return arch;
+    }
+
+    public boolean isLinux() {
+        return os == OS.LINUX;
+    }
+
+    public boolean isMac() {
+        return os == OS.MAC;
+    }
+
+    public boolean isWindows() {
+        return os == OS.WINDOWS;
+    }
+
+    public String toString() {
+        return "OS '" + os + "', arch '" + arch + "'";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Platform platform = (Platform) o;
+        return os == platform.os && arch == platform.arch;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(os, arch);
+    }
+
+    /**
+     * Get information on the host platform the launcher is currently running on.
+     *
+     * @return the platform
+     */
+    public static Platform getPlatform() throws UnsupportedPlatformException {
+        final String platformOs = System.getProperty("os.name").toLowerCase();
+        final OS os;
+        if (platformOs.startsWith("linux")) {
+            os = OS.LINUX;
+        } else if (platformOs.startsWith("mac os")) {
+            os = OS.MAC;
+        } else if (platformOs.startsWith("windows")) {
+            os = OS.WINDOWS;
+        } else {
+            throw new UnsupportedPlatformException("Unsupported OS: " + platformOs);
+        }
+
+        final String platformArch = System.getProperty("os.arch");
+        final Arch arch;
+        switch (platformArch) {
+            case "x86_64":
+            case "amd64":
+                arch = Arch.X64;
+                break;
+            case "x86":
+            case "i386":
+                arch = Arch.X86;
+                break;
+            case "aarch64":
+            case "arm64":
+                arch = Arch.ARM64;
+                break;
+            default:
+                throw new UnsupportedPlatformException("Architecture not supported: " + platformArch);
+        }
+
+        return new Platform(os, arch);
+    }
+}

src/main/java/org/terasology/launcher/platform/UnsupportedPlatformException.java

@@ -0,0 +1,15 @@
+// Copyright 2023 The Terasology Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+package org.terasology.launcher.platform;
+
+public class UnsupportedPlatformException extends Exception {
+
+    public UnsupportedPlatformException() {
+        super();
+    }
+
+    public UnsupportedPlatformException(String message) {
+        super(message);
+    }
+}

src/main/java/org/terasology/launcher/util/LauncherDirectoryUtils.java

@@ -5,6 +5,7 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.terasology.launcher.platform.Platform;
 
 import java.io.IOException;
 import java.net.URISyntaxException;