Add module that about java runtime management to core_lib.

core_lib/common/common.py

@@ -19,12 +19,13 @@ THREADED_DOWNLOAD_MAX_WORKERS = 10
 logger = logging.getLogger("Launcher.CoreLib")
 
 class FileObject:
-    def __init__(self, path: Path, url=None, sha1=None, sha256=None, md5=None):
+    def __init__(self, path: Path, url=None, sha1=None, sha256=None, md5=None, size=None):
         self.__path = path
 
         self.expected_sha1 = sha1
         self.expected_sha256 = sha256
         self.expected_md5 = md5
+        self.expected_size = size
 
         self.__sha1 = None
         self.__sha256 = None
@@ -98,8 +99,14 @@ class FileObject:
         if algorithm == "md5":
             return self.verify_md5(expected_hash if expected_hash else self.expected_md5)
 
+        if algorithm == "size":
+            return self.verify_size(expected_hash if expected_hash else self.expected_size)
+
         raise Exception("Unsupported algorithm: {}".format(algorithm))
 
+    def verify_size(self, expected_size):
+        return self.size == expected_size if expected_size else self.expected_size == self.size
+
     def _calculate_hash(self, algorithm):
         h = hashlib.new(algorithm)
 
@@ -262,6 +269,7 @@ def unzip(filepath: Path, destination: Path, exclude: list[str] | None = None, f
 def get_platform_info():
     """
     Get information about the current platform.
+    IMPORTANT: All return values are lower-case
     :return:
         platform_name: str, architecture: str, os_version: str
     """

core_lib/common/exception.py

@@ -63,3 +63,15 @@ class AssetManifestException(LauncherException):
 
 class AssetDataKeyNotFoundException(LauncherException):
     user_message = "Specified asset data section (key) not found."
+
+class JavaRuntimeException(LauncherException):
+    user_message = "An error occurred while executing Java runtime."
+
+class JavaRuntimeParseException(JavaRuntimeException):
+    user_message = "Unable to parse Java runtime details."
+
+class RuntimeManifestFetchException(LauncherException):
+    user_message = "Unable to fetch runtime manifest."
+
+class RuntimeManifestDataException(LauncherException):
+    user_message = "Runtime manifest is missing or corrupted."

core_lib/game/asset.py

@@ -2,18 +2,20 @@ import json
 import logging
 import shutil
 from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 import requests
 
 from core_lib.common.common import FileObject, download_multiple_files
 from core_lib.common.exception import VersionDataKeyNotFoundException, AssetManifestFetchException, \
-    HashMismatchException, AssetManifestSaveException, AssetDataKeyNotFoundException
+    HashMismatchException, AssetManifestSaveException, AssetDataKeyNotFoundException, DownloadException
 from core_lib.game.version_info import find_useful_part_in_specific_version_manifest
 
 MOJANG_RESOURCE_ENDPOINT = "https://resources.download.minecraft.net/{beginning}/{hash}"
 
 ASSET_DOWNLOAD_MAX_WORKERS = 20
+ASSET_CHECK_MAX_WORKERS = 20
 
 logger = logging.getLogger("Launcher.CoreLib")
 
@@ -101,12 +103,72 @@ def fetch_and_save_asset_manifest(target_version_manifest: dict, destination: Pa
             "Error saving version manifest:\n{}".format(e)
         )
 
-def collect_assets_from_manifest(asset_id: str, manifest: dict, assets_dir: Path) -> tuple[list[FileObject], list[dict]]:
+def _check_asset(asset_id: str, asset_data: dict, relative_path: str, assets_dir: Path, virtual: bool, no_hash_check: bool=False)\
+        -> tuple[FileObject | None, dict | None]:
     """
-    Collect assets from asset manifest.
-    :param asset_id:
-    :param manifest:
+    Check if asset exists.
+    :param asset_data:
+    :param relative_path:
     :param assets_dir:
+    :param virtual:
+    :return:
+        asset_file: FileObject
+        legacy_context: dict
+    """
+    hash_raw = asset_data.get("hash", "")
+    expected_size = asset_data.get("size")
+
+    if not hash_raw:
+        raise AssetDataKeyNotFoundException(
+            "Asset that inside assets section (objects) missing hash."
+        )
+
+    beginning = hash_raw[:2]
+
+    full_path = Path(assets_dir, "objects", beginning, hash_raw)  # For newer assets
+    full_url = MOJANG_RESOURCE_ENDPOINT.format(beginning=beginning, hash=hash_raw)
+    file = FileObject(path=full_path, sha1=hash_raw, url=full_url)
+
+    needs_download = True
+
+    if full_path.exists() and full_path.is_file():
+        if no_hash_check and expected_size is not None:
+            needs_download = full_path.stat().st_size != expected_size
+        else:
+            needs_download = not file.verify_sha1(hash_raw)
+
+        if not needs_download:
+            suffix = " (no_hash_check=True)" if no_hash_check else ""
+            logger.debug(
+                "Asset hash {} (Aka {}) already exists.{}".format(
+                    hash_raw,
+                    relative_path,
+                    suffix,
+                )
+            )
+
+    legacy_context = None
+    if virtual:
+        legacy_context = {
+            "file": file,
+            "target": full_path if virtual else None,
+            "sha1": hash_raw,
+            "destination": Path(assets_dir, "virtual", asset_id, relative_path) if virtual else None,
+            "size": expected_size,
+        }
+
+    return file if needs_download else None, legacy_context
+
+def collect_assets_from_manifest(manifest: dict, asset_id: str, assets_dir: Path,
+                                 max_workers=ASSET_CHECK_MAX_WORKERS,
+                                 no_hash_check=False) -> tuple[list[FileObject], list[dict]]:
+    """
+    Collect assets from asset manifest. (Only return items that does not exist)
+    :param no_hash_check:
+    :param manifest:
+    :param asset_id:
+    :param assets_dir:
+    :param max_workers:
     :return:
         assets: list[FileObject]
         legacy_assets: list[dict] (Contains target and destination of the legacy asset)
@@ -122,64 +184,51 @@ def collect_assets_from_manifest(asset_id: str, manifest: dict, assets_dir: Path
             "Assets section (objects) not found in asset manifest."
         )
 
-    for relative_path in objects:
-        data = objects[relative_path]
-        hash_raw = data.get("hash", "")
-
-        if not hash_raw:
-            raise AssetDataKeyNotFoundException(
-                "Asset that inside assets section (objects) missing hash."
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [
+            executor.submit(
+                _check_asset,
+                asset_id, objects[relative_path], relative_path, assets_dir, virtual,
+                no_hash_check=no_hash_check
             )
+            for relative_path in objects
+        ]
 
-        beginning = hash_raw[:2]
+        for future in as_completed(futures):
+            asset_file, legacy_context = future.result()
 
-        full_path = Path(assets_dir, "objects", beginning, hash_raw) # For newer assets
-        full_path.parent.mkdir(parents=True, exist_ok=True)
-        full_url = MOJANG_RESOURCE_ENDPOINT.format(beginning=beginning, hash=hash_raw)
-        file = FileObject(path=full_path, sha1=hash_raw, url=full_url)
+            if asset_file:
+                files.append(asset_file)
 
-        if virtual:
-            # For legacy assets
-            full_path_old = Path(assets_dir, "virtual", asset_id, relative_path)
-            legacy_assets.append({
-                "target": full_path,
-                "destination": full_path_old,
-                "sha1": hash_raw,
-            })
-
-        if (full_path.exists() and full_path.is_file()) and file.verify_sha1(hash_raw):
-            logger.debug("Asset hash {} (Aka {}) already exists.".format(hash_raw, relative_path))
-            continue
-
-        files.append(file)
+            # Also copy the asset into legacy directory if needed.
+            if legacy_context:
+                legacy_assets.append(legacy_context)
 
     return files, legacy_assets
 
 
-def download_assets_and_copy(assets: list[FileObject], legacy_assets: list[dict], progress_callback: Callable[str]) -> list[FileObject]:
+def download_assets_and_copy(assets: list[FileObject], legacy_assets: list[dict],
+                             no_hash_check: bool=False, allow_missing=False,
+                             progress_callback: Callable[str]=None,
+                             redownload_callback: Callable[[list[FileObject]], tuple[bool, list[FileObject]]]=None) -> list[FileObject]:
     """
     Download assets from target version's asset manifest. (Not sure why this function exist, may for compatibly)
     Also, this function will copy
     :param assets:
     :param legacy_assets:
+    :param no_hash_check:
+    :param allow_missing:
     :param progress_callback:
+    :param redownload_callback:
     :return:
         files: list[FileObject] (files that download failed)
     """
 
-    fails , _ = download_multiple_files(assets, progress_callback=progress_callback,
-                                        max_workers=ASSET_DOWNLOAD_MAX_WORKERS)
-
-    if fails:
-        logger.warning(
-            "Download failed for assets: \n"
-            +"\n".join([asset.posix_path for asset in fails])
-        )
-
-    for asset in legacy_assets:
+    def __worker(asset: dict):
         target = asset.get("target")
         destination = asset.get("destination")
         sha1 = asset.get("sha1")
+        size = asset.get("size")
 
         if not target or not destination:
             raise ValueError(
@@ -188,18 +237,60 @@ def download_assets_and_copy(assets: list[FileObject], legacy_assets: list[dict]
 
         # Check source file
         source_asset = FileObject(path=target)
-        if not source_asset.exists or (sha1 and not source_asset.verify("sha1", sha1)):
+
+        if (not source_asset.exists or
+            (not no_hash_check and sha1 and not source_asset.verify("sha1", sha1))):
             logger.warning("Target asset {} not found.".format(target))
-            continue
+            return False, None
 
         destination.parent.mkdir(parents=True, exist_ok=True)
 
         # Check destination file
         old_asset = FileObject(path=destination)
-        if old_asset.exists and (sha1 and old_asset.verify("sha1", sha1)):
-            continue
+        if old_asset.exists:
+            if no_hash_check and size is not None:
+                if old_asset.path.stat().st_size == size:
+                    logger.debug("Asset {} already exists. (no_hash_check=True)".format(target))
+                    return True, None
+            elif sha1 and old_asset.verify("sha1", sha1):
+                logger.debug("Asset {} already exists.".format(target))
+                return True, None
 
         shutil.copyfile(target, destination)
+        return True, destination
+
+    fails , _ = download_multiple_files(assets, progress_callback=progress_callback,
+                                        max_workers=ASSET_DOWNLOAD_MAX_WORKERS)
+
+
+    download_ok = len(fails) == 0
+
+    if fails and callable(redownload_callback):
+        download_ok, fails = redownload_callback(fails)
+
+    if not download_ok:
+        logger.warning(
+            "Download failed for assets: \n"
+            +"\n".join([asset.posix_path for asset in fails])
+        )
+        if not allow_missing:
+            return fails
+
+    # Use thread pool to handle copy file process
+    with ThreadPoolExecutor(max_workers=ASSET_DOWNLOAD_MAX_WORKERS) as executor:
+        futures = [
+            executor.submit(
+                __worker,
+                asset
+            )
+            for asset in legacy_assets
+        ]
+
+        for future in as_completed(futures):
+            result, dest = future.result()
+
+            if result and dest:
+                logger.debug("Created: {}".format(dest))
 
     return fails
 
@@ -249,3 +340,41 @@ def correct_assets_name_and_copy(manifest: dict, assets_dir: Path, output_dir: P
         shutil.copy(file.posix_path, full_path_new.as_posix())
 
     return missing
+
+def download_assets(manifest: dict, assets_dir: Path, no_hash_check: bool=False,
+                    progress_callback:  Callable[[str, float], None]=None,
+                    redownload_callback: Callable[[list[FileObject]], tuple[bool, list[FileObject]]]=None) -> list[FileObject]:
+    _, asset_index, _, _, _, _, _ = find_useful_part_in_specific_version_manifest(manifest)
+
+    asset_id = asset_index.get("id")
+
+    if not asset_id:
+        raise VersionDataKeyNotFoundException(
+            "Asset ID is missing."
+        )
+
+    index_path = Path(assets_dir, "indexes", f"{asset_id}.json")
+
+    # Download and save asset manifest
+    asset_manifest = fetch_and_save_asset_manifest(
+        manifest,
+        index_path,
+    )
+
+    # Download assets files
+    assets, legacy_assets = collect_assets_from_manifest(
+        asset_manifest,
+        asset_id,
+        assets_dir,
+        no_hash_check=no_hash_check,
+    )
+
+    fails = download_assets_and_copy(
+        assets,
+        legacy_assets,
+        progress_callback=progress_callback,
+        no_hash_check=no_hash_check,
+        redownload_callback=redownload_callback,
+    )
+
+    return fails

core_lib/game/library.py

@@ -14,7 +14,7 @@ from .version_info import (
     NATIVE_OLD_TO_NEW_ARCH, find_useful_part_in_specific_version_manifest,
 )
 from ..common.exception import UnsupportedPlatformException, NativeResolveException, DependencyException, \
-    VersionDataKeyNotFoundException
+    VersionDataKeyNotFoundException, DownloadException
 
 logger = logging.getLogger("Launcher.CoreLib")
 
@@ -439,7 +439,8 @@ def collect_native_artifacts(specific_version_manifest):
 
     return items
 
-def download_libraries(artifacts, output_dir, progress_callback: Callable[[str], None]):
+def download_libraries(artifacts, output_dir, progress_callback: Callable[[str, float], None]=None) \
+        -> tuple[list[FileObject], list[FileObject]]:
     """
     Download libraries from a list that contains artifacts
     :param artifacts:
@@ -450,6 +451,7 @@ def download_libraries(artifacts, output_dir, progress_callback: Callable[[str],
         successes: list (artifacts that were downloaded)
     """
     files = []
+    successes = []
 
     for artifact in artifacts:
         sha1 = artifact.get("sha1")
@@ -475,15 +477,16 @@ def download_libraries(artifacts, output_dir, progress_callback: Callable[[str],
 
         if file.exists and (sha1 is None or file.verify("sha1", sha1)):
             logger.debug(f"File {full_path} exists.")
+            successes.append(file)
             continue
 
         files.append(file)
 
-    fails, successes = download_multiple_files(files, progress_callback=progress_callback)
+    fails, finished = download_multiple_files(files, progress_callback=progress_callback)
+    successes.extend(finished)
 
     return fails, successes
 
-
 def unzip_natives(filtered, libraries_dir, destination: Path):
     """
     Unzip native libraries from a list that contains artifacts
@@ -642,3 +645,43 @@ def generate_classpath(manifest: dict, libraries_dir: Path, core_file_path: Path
 
     return f"{separator}".join(classes)
 
+def download_full_libraries(manifest: dict, libraries_dir: Path, natives_dir: Path,
+                            progress_callback:  Callable[[str, float], None]=None,
+                            redownload_callback: Callable[[list[FileObject]], tuple[bool, list[FileObject]]]=None) -> None:
+    # libraries
+    libraries = collect_library_artifacts(manifest)
+
+    # natives
+    natives = collect_native_artifacts(manifest)
+
+    # all
+    full = list(libraries)
+    full.extend(natives)
+
+    logger.info(
+        "Supported native count: {}".format(len(natives))
+    )
+
+    # Start download
+    fails, successes = download_libraries(full, libraries_dir, progress_callback=progress_callback)
+
+    download_ok = len(fails) == 0
+
+    if redownload_callback and not download_ok:
+        download_ok, fails = redownload_callback(fails)
+
+        if not download_ok:
+            raise DownloadException(
+                "Unable to continue process due to certain libraries download failed:\n"
+                + "\n".join(file.posix_path for file in fails)
+            )
+
+    if download_ok:
+        # Start unzip natives
+        unzip_natives(natives, libraries_dir, natives_dir)
+    else:
+        raise DependencyException(
+            "Certain libraries download failed. Unable to continue unzip process.\n"
+        )
+
+

core_lib/game/version_info.py

@@ -1,11 +1,13 @@
 import json
 import logging
+import re
 import warnings
+from collections.abc import Callable
 from pathlib import Path
 
 import requests
 
-from ..common.common import FileObject
+from ..common.common import FileObject, download_file
 from ..common.exception import VersionManifestFetchException, NoVersionFoundException, \
     NoSpecifiedVersionKeyException, VersionDataKeyNotFoundException, VersionManifestSaveException, HashMismatchException
 
@@ -61,6 +63,43 @@ NATIVE_NEW_TO_OLD_ARCH = {
     "x86_64": "64",
 }
 
+RUNTIME_PLATFORM_MAP = {
+    "linux": "linux",
+    "darwin": "mac-os",
+    "macos": "mac-os",
+    "osx": "mac-os",
+    "windows": "windows",
+    "win32": "windows",
+    "cygwin": "windows",
+    "msys": "windows",
+}
+
+RUNTIME_ARCH_EMPTY = "$EMPTY"
+
+RUNTIME_ARCH_MAP = {
+    "linux": {
+        "i386": "i386",
+        "i686": "i386",
+        "x86": "i386",
+        "amd64": RUNTIME_ARCH_EMPTY,
+        "x86_64": RUNTIME_ARCH_EMPTY,
+    },
+    "windows": {
+        "i386": "x86",
+        "i686": "x86",
+        "x86": "x86",
+        "amd64": "x64",
+        "x86_64": "x64",
+        "aarch64": "arm64",
+        "arm64": "arm64",
+    },
+    "mac-os": {
+        "amd64": RUNTIME_ARCH_EMPTY,
+        "x86_64": RUNTIME_ARCH_EMPTY,
+        "aarch64": "arm64",
+        "arm64": "arm64",
+    },
+}
 
 logger = logging.getLogger("Launcher.CoreLib")
 
@@ -227,7 +266,7 @@ def get_specific_version_manifest_url_and_hash(version_manifest: dict, version_i
     for version in versions:
         if version.get("id") == version_id:
             specific_ver_manifest_url = version.get("url", None)
-            specific_ver_manifest_hash = version.get("hash", None)
+            specific_ver_manifest_hash = version.get("sha1", None)
 
             if specific_ver_manifest_url is None:
                 raise VersionManifestFetchException(
@@ -244,13 +283,13 @@ def get_specific_version_manifest_url_and_hash(version_manifest: dict, version_i
     )
 
 
-def fetch_specific_version_manifest(version_manifest: dict, spec_version: str) -> tuple[dict, str | None]:
+def fetch_specific_version_manifest(version_manifest: dict, spec_version: str) -> tuple[bytes, str | None]:
     """
     Get specific version's manifest data and hash from version manifest.
     :param version_manifest:
     :param spec_version:
     :return:
-        specific_version_manifest_data: str
+        specific_version_manifest_data: bytes
         hash: str (sha1)
     """
     ver_url, sha1 = get_specific_version_manifest_url_and_hash(version_manifest, spec_version)
@@ -263,14 +302,7 @@ def fetch_specific_version_manifest(version_manifest: dict, spec_version: str) -
             "Failed to fetch version manifest URL: {}\n{}".format(ver_url, e)
         )
 
-    try:
-        data = r.json()
-        logger.debug("SpecificVersionManifest: {}".format(json.dumps(data, indent=4)))
-        return data, sha1
-    except ValueError as e:
-        raise VersionManifestFetchException(
-            "Unable to deserialize response data into dictionary: {} (TargetVer: {})".format(e, ver_url)
-        )
+    return r.content, sha1
 
 # mapping
 get_specific_version_manifest = fetch_specific_version_manifest
@@ -400,8 +432,12 @@ def fetch_and_save_version_manifest(dest: Path, target_version: str=None, root_m
     dest.parent.mkdir(parents=True, exist_ok=True)
 
     try:
-        with dest.open("w") as f:
-            json.dump(data, f, indent=4)
+        method = "wb" if isinstance(data, bytes) else "w"
+        with dest.open(method) as f:
+            if isinstance(data, bytes):
+                f.write(data)
+            elif isinstance(data, dict):
+                json.dump(data, f)
 
         if sha1 is not None and not file.verify_sha1(sha1):
             raise HashMismatchException(
@@ -411,9 +447,48 @@ def fetch_and_save_version_manifest(dest: Path, target_version: str=None, root_m
                 file.posix_path
             )
 
-        return data
+        if isinstance(data, bytes):
+            # Convert the data back to dict
+            return json.loads(data.decode("utf-8"))
+        else:
+            return data
     except Exception as e:
         logger.exception(e)
         raise VersionManifestSaveException(
             "Error saving version manifest:\n{}".format(e)
         )
+
+def download_core_file(manifest: dict, destination: Path, is_server=False, raise_for_null_hash=False,
+                       progress_callback: Callable[str]=None) -> FileObject:
+    """
+    Download core file from version manifest.
+    :param manifest:
+    :param destination:
+    :param is_server:
+    :param raise_for_null_hash:
+    :param progress_callback:
+    :return:
+        client_file: FileObject
+    """
+    url, sha1 = get_core_file_download_url_and_hash(manifest, is_server=is_server)
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    file = FileObject(destination, url=url)
+
+    if sha1 is None and raise_for_null_hash:
+        raise VersionDataKeyNotFoundException(
+            "Core file hash is missing. Enable \"raise_for_null_hash\" flag to ignore this exception.\n"
+        )
+    elif sha1 is None:
+        logger.warning("Client has no sha1.")
+
+    if file.exists and file.verify("sha1", sha1):
+        logger.info(f"Client existed and sha1 matches.")
+    elif url is not None:
+        download_file(file, progress_callback=progress_callback)
+    elif not url:
+        raise VersionDataKeyNotFoundException(
+            "Core file url is None. Unable to download it."
+        )
+
+    return file

core_lib/qt/messagebox.py

@@ -1,4 +1,6 @@
-from PySide6.QtWidgets import QMessageBox, QMainWindow, QWidget
+from PySide6.QtWidgets import QMessageBox, QMainWindow, QWidget, QDialog, QVBoxLayout, QLabel, QPlainTextEdit, \
+    QDialogButtonBox, QSizePolicy
+
 
 def create_messagebox(parent: QWidget, title: str, message: str,
                       icon: QMessageBox.Icon = QMessageBox.Icon.Information,
@@ -42,3 +44,33 @@ def warning(parent: QWidget, title: str, message: str,
         icon=QMessageBox.Icon.Warning,
         button=button
     ).exec()
+
+
+def ask_yes_no_with_plain_text(parent: QWidget, title: str, message: str, content: str):
+    dialog = QDialog(parent)
+    dialog.setWindowTitle(title)
+    dialog.resize(720, 420)
+
+    layout = QVBoxLayout(dialog)
+
+    label = QLabel(message)
+    label.setWordWrap(True)
+    label.setWordWrap(True)
+
+    details_box = QPlainTextEdit()
+    details_box.setReadOnly(True)
+    details_box.setPlainText(content)
+    details_box.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+    buttons = QDialogButtonBox(
+        QDialogButtonBox.StandardButton.Yes |
+        QDialogButtonBox.StandardButton.No
+    )
+    buttons.button(QDialogButtonBox.StandardButton.Yes).clicked.connect(dialog.accept)
+    buttons.button(QDialogButtonBox.StandardButton.No).clicked.connect(dialog.reject)
+
+    layout.addWidget(label)
+    layout.addWidget(details_box, 1)
+    layout.addWidget(buttons)
+
+    return dialog.exec() == QDialog.DialogCode.Accepted

core_lib/runtime/java.py

@@ -0,0 +1,151 @@
+import glob
+import logging
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from core_lib.common.exception import JavaRuntimeException, JavaRuntimeParseException
+
+logger = logging.getLogger("Launcher.CoreLib")
+
+def get_java_version(java_executable_path: str | Path) -> tuple[int, str]:
+    if isinstance(java_executable_path, Path):
+        java_executable_path = java_executable_path.as_posix()
+
+    try:
+        process = subprocess.run(
+            [java_executable_path, "-version"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=10,
+        )
+    except subprocess.TimeoutExpired:
+        raise JavaRuntimeException(
+            "Java runtime timed out.",
+        )
+    except subprocess.CalledProcessError as e:
+        raise JavaRuntimeException(
+            "Unable to run Java runtime: {}".format(e.stderr),
+        )
+    except Exception as e:
+        raise JavaRuntimeException(
+            "An error occurred while executing Java runtime: {}".format(e),
+        )
+
+    output = (process.stderr or "") + "\n" + (process.stdout or "")
+
+    match = re.search(r'version "([^"]+)"', output)
+    if not match:
+        raise JavaRuntimeParseException(
+            f"Unable to parse Java version:\n{output}"
+        )
+
+    raw_version = match.group(1)
+
+    if raw_version.startswith("1."):
+        major = int(raw_version.split(".")[1])
+    else:
+        major = int(raw_version.split(".")[0])
+
+    return major, raw_version
+
+def find_java_installations(extra_install_patterns: list | None=None) -> list[dict]:
+    candidates_paths = []
+    installations = []
+
+    java_executable_name = "java.exe" if sys.platform == "win32" else "java"
+
+    # Check (system) environment
+    path_java = shutil.which("java")
+    if path_java:
+        candidates_paths.append(Path(path_java))
+
+    java_home = os.environ.get("JAVA_HOME")
+    if java_home:
+        candidates_paths.append(Path(java_home) / "bin" / java_executable_name)
+
+    system = platform.system().lower()
+
+    if system == "windows":
+        patterns = [
+            r"C:\Program Files\Java\*\bin\java.exe",
+            r"C:\Program Files\Eclipse Adoptium\*\bin\java.exe",
+            r"C:\Program Files\Microsoft\jdk-*\bin\java.exe",
+            r"C:\Program Files (x86)\Java\*\bin\java.exe",
+        ]
+    elif system == "darwin":
+        patterns = [
+            "/Library/Java/JavaVirtualMachines/*/Contents/Home/bin/java",
+            "/System/Library/Java/JavaVirtualMachines/*/Contents/Home/bin/java",
+            "/opt/homebrew/opt/openjdk*/bin/java",
+            "/usr/local/opt/openjdk*/bin/java",
+            "/Applications/*/Contents/jbr/Contents/Home/bin/java",
+        ]
+
+    else:
+        patterns = [
+            "/usr/bin/java",
+            "/bin/java",
+            "/usr/local/bin/java",
+            "/usr/lib/jvm/*/bin/java",
+            "/opt/java/*/bin/java",
+            "/opt/jdk*/bin/java",
+            "/snap/*/current/bin/java",
+        ]
+
+    if isinstance(extra_install_patterns, list):
+        patterns.extend(extra_install_patterns)
+
+    for pattern in patterns:
+        candidates_paths.extend(Path(p) for p in glob.glob(pattern))
+
+    seen = set()
+    errors = []
+
+    for candidate_path in candidates_paths:
+        try:
+            converted_path = candidate_path.resolve().absolute()
+        except OSError:
+            continue
+
+        if converted_path in seen:
+            continue
+
+        ver = None
+        raw = None
+
+        try:
+            ver, raw = get_java_version(converted_path)
+        except JavaRuntimeParseException:
+
+            logger.debug(f"Unable to parse java version: {converted_path}")
+        except JavaRuntimeException:
+            logger.debug(f"Unable to run java executable: {converted_path}")
+        except Exception as e:
+            logger.exception(f"Unhandled exception: {e} (For path: {converted_path})")
+        finally:
+            if not ver:
+                errors.append(converted_path)
+                continue
+
+        logger.debug(f"Detected java version {ver} for path: {converted_path}")
+
+        installations.append(
+            {
+                "major": ver,
+                "raw": raw,
+                "homeDir": converted_path.parent.parent,
+                "executable": converted_path,
+            }
+        )
+
+    installations.sort(key=lambda item: item["major"], reverse=True)
+
+    return installations

core_lib/runtime/mojang.py

@@ -0,0 +1,353 @@
+import hashlib
+import json
+import logging
+import platform
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Callable
+
+import requests
+
+from ..common.common import get_platform_info, FileObject, download_multiple_files
+from ..common.exception import RuntimeManifestFetchException, UnsupportedPlatformException, \
+    RuntimeManifestDataException, HashMismatchException, DownloadException
+from ..game.version_info import RUNTIME_PLATFORM_MAP, RUNTIME_ARCH_EMPTY, RUNTIME_ARCH_MAP
+
+MOJANG_RUNTIME_MANIFEST = "https://launchermeta.mojang.com/v1/products/java-runtime/2ec0cc96c44e5a76b9c8b7c39df7210883d12871/all.json"
+RUNTIME_CHECK_MAX_WORKERS = 10
+RUNTIME_DOWNLOAD_MAX_WORKERS = 12
+
+logger = logging.getLogger("Launcher.CoreLib")
+
+
+def get_current_platform_runtime_key() -> str | None:
+    """
+    Get the current platform runtime key.
+    :return:
+        runtime_key: str
+    """
+    platform_name, arch, os_version = get_platform_info()
+
+    runtime_os_name = RUNTIME_PLATFORM_MAP.get(platform_name, None)
+
+    if runtime_os_name is None:
+        return None
+
+    runtime_arch_name = RUNTIME_ARCH_MAP.get(runtime_os_name, {}).get(arch, None)
+
+    if runtime_arch_name is None:
+        return None
+
+    # If architecture type is x86_64, some platform's runtime key is same as runtime_os_name. (Such as linux and macOS)
+    if runtime_arch_name == RUNTIME_ARCH_EMPTY:
+        return runtime_os_name
+
+    full_key = f"{runtime_os_name}-{runtime_arch_name}"
+
+    return full_key
+
+
+def fetch_runtime_manifest(manifest_url=MOJANG_RUNTIME_MANIFEST, timeout=10) -> dict:
+    """
+    Fetch the runtime manifest data.
+    :param manifest_url:
+    :param timeout:
+    :return:
+        root_manifest: dict
+    """
+    logger.debug("Getting version manifest from {}".format(manifest_url))
+
+    try:
+        r = requests.get(manifest_url, timeout=timeout)
+        r.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        raise RuntimeManifestFetchException(
+            "Unable to fetch runtime manifest from {}: {}".format(manifest_url, e),
+        )
+
+    try:
+        data = r.json()
+        logger.debug("RuntimeManifest: {}".format(json.dumps(data, indent=4)))
+        return data
+    except ValueError as e:
+        raise RuntimeManifestFetchException(
+            "Unable to deserialize response data into dictionary: {}".format(e)
+        )
+
+
+def find_support_runtime_manifests_info(root_runtime_manifest: dict, require_component: str) -> list:
+    """
+    Find support runtime manifest (info) by platform.
+    :param root_runtime_manifest:
+    :param require_component:
+    :return:
+        manifests_info: list
+    """
+    runtime_key = get_current_platform_runtime_key()
+
+    if not runtime_key:
+        raise UnsupportedPlatformException(
+            "Theres no runtime support the current platform or architecture."
+        )
+
+    runtime_section = root_runtime_manifest.get(runtime_key, {})
+
+    if not runtime_section:
+        raise RuntimeManifestDataException(
+            "Root runtime manifest missing runtime key {} data.".format(runtime_key)
+        )
+
+    runtimes = runtime_section.get(require_component, [])
+
+    if not runtimes:
+        raise RuntimeManifestDataException(
+            "Found require component section. But is empty: {}".format(require_component))
+
+    usable = [
+        item for item in runtimes
+        if item.get("manifest", {}).get("url")
+    ]
+
+    if not usable:
+        raise RuntimeManifestDataException(
+            "No usable runtime manifest data found for component {}".format(require_component)
+        )
+
+    return usable
+
+
+def get_support_runtime_manifest(root_runtime_manifest: dict, require_component: str, no_hash_check=False) -> dict:
+    runtime_info = find_support_runtime_manifests_info(root_runtime_manifest, require_component)[0]
+    manifest_info = runtime_info.get("manifest", {})
+    url = manifest_info.get("url")
+    expected_sha1 = manifest_info.get("sha1")
+
+    if not url:
+        raise RuntimeManifestDataException(
+            "Runtime info missing manifest url"
+        )
+
+    if not expected_sha1 and not no_hash_check:
+        raise RuntimeManifestDataException(
+            "Runtime manifest missing sha1 data from {}".format(url)
+        )
+
+    # Fetch data
+    try:
+        r = requests.get(url, timeout=10)
+        r.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        raise RuntimeManifestFetchException(
+            "Unable to fetch runtime manifest from {}: {}".format(url, e),
+        )
+
+    # Verify it and convert it to dict
+    content = r.content
+    actual_sha1 = hashlib.sha1(content).hexdigest()
+    try:
+        if not no_hash_check and actual_sha1 != expected_sha1:
+            raise RuntimeManifestFetchException(
+                "Hash mismatch for runtime manifest from url {} got {} "
+                "and root manifest expected {}".format(url, actual_sha1, expected_sha1)
+            )
+
+        data = json.loads(content.decode("utf-8"))
+        logger.debug("RuntimeManifest: {}".format(json.dumps(data, indent=4)))
+        return data
+    except Exception as e:
+        raise RuntimeManifestFetchException(
+            "Unable to fetch runtime manifest from {}: {}".format(url, e),
+        )
+
+
+def _check_runtime_file(relative_path, file_type: str, sha1: str | None, size: str | None, url: str | None,
+                        executable: bool, runtime_dir: Path, no_hash_check: bool = False) -> tuple[
+    bool, FileObject | Path | None]:
+    full_path = runtime_dir / Path(relative_path)
+
+    if (not sha1 and not no_hash_check) and file_type == "file":
+        raise RuntimeManifestDataException(
+            "Runtime manifest missing sha1 data from {}".format(url)
+        )
+
+    if not url and file_type == "file":
+        raise RuntimeManifestDataException(
+            "Runtime manifest missing file url. {}".format(relative_path)
+        )
+
+    if not file_type:
+        raise RuntimeManifestDataException(
+            "Runtime manifest missing file type. {}".format(relative_path)
+        )
+
+    needs_download = True
+    if file_type == "file":
+        target_file = FileObject(
+            path=full_path,
+            sha1=sha1,
+            size=size,
+            url=url,
+        )
+
+        if not target_file.expected_sha1 and not no_hash_check:
+            raise RuntimeManifestDataException(
+                "Runtime file hash is missing."
+            )
+
+        # Check file exist
+        if target_file.exists and target_file.path.is_file():
+            if no_hash_check and target_file.expected_size is not None:
+                needs_download = not target_file.verify("size")
+            else:
+                needs_download = not target_file.verify("sha1")
+
+            if not needs_download:
+                suffix = " (no_hash_check=True)" if no_hash_check else ""
+                logger.debug(
+                    "Runtime file {} already exists.{}".format(
+                        target_file,
+                        suffix
+                    )
+                )
+    elif file_type == "directory":
+        target_file = Path(full_path)
+        if target_file.exists() and target_file.is_dir():
+            needs_download = False
+    else:
+        raise RuntimeManifestDataException(
+            "Unsupported file type: {}".format(file_type)
+        )
+
+    return executable == True, target_file if needs_download else None
+
+
+def collect_runtime_files(manifest: dict, runtime_dir: Path, max_workers=RUNTIME_CHECK_MAX_WORKERS,
+                          no_hash_check=False, use_raw=True) -> tuple[list[FileObject], list[FileObject], list[Path]]:
+    """
+    Download runtime files from given manifest.
+    :param manifest:
+    :param runtime_dir:
+    :param max_workers:
+    :param no_hash_check:
+    :param use_raw: Download raw files instead of download compressed files.
+    :return:
+        executables: Executable files that need to be downloaded and fix permission on some platform
+        files: Runtime files that need to be downloaded
+        dirs: Directories that need to be created
+    """
+    result_executables = []
+    result_files = []
+    result_dirs = []
+    files = manifest.get("files", {})
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = []
+
+        for relative_path in files:
+            data = files[relative_path]
+            downloads = data.get("downloads", {})
+            artifact = downloads.get("raw" if use_raw else "lzma", {})
+            file_type = data.get("type")
+            sha1 = artifact.get("sha1")
+            size = artifact.get("size")
+            url = artifact.get("url")
+            executable = data.get("executable", False)
+
+            futures.append(executor.submit(_check_runtime_file, relative_path, file_type, sha1, size, url,
+                                           executable, runtime_dir, no_hash_check))
+
+
+        for future in as_completed(futures):
+            is_executable, file = future.result()
+
+            if file and isinstance(file, FileObject) and not is_executable:
+                result_files.append(file)
+            elif file and isinstance(file, FileObject) and is_executable:
+                result_executables.append(file)
+            elif file and isinstance(file, Path):
+                result_dirs.append(file)
+
+    if not use_raw:
+        logger.warning(
+            "Flag \"raw\" is not enabled. But the launcher haven't implemented support for compressed files."
+            "You will likely to decompress all files before use them."
+        )
+
+    return result_executables, result_files, result_dirs
+
+
+def handle_runtime_dir_and_executable_process(dirs: list[Path], executables: list[Path | FileObject], max_workers=6):
+    def _worker(path: Path | FileObject, is_executable: bool):
+        if isinstance(path, FileObject):
+            path = path.path
+
+        if is_executable:
+            if platform.system() != "Windows" and path.exists():
+                path.chmod(path.stat().st_mode | 0o755)
+            return
+
+        path.mkdir(parents=True, exist_ok=True)
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [
+            executor.submit(
+            _worker,
+            path,
+            False)
+            for path in dirs
+        ]
+
+        futures.extend(
+            executor.submit(_worker, path, True)
+            for path in executables
+        )
+        for future in as_completed(futures):
+            future.result()
+
+
+def download_java_runtimes(component: str, runtime_dir: Path, no_hash_check: bool = False,
+                           progress_callback: Callable[[str, float], None] = None,
+                           redownload_callback: Callable[[list[FileObject]], tuple[bool, list[FileObject]]] = None,
+                           max_download_workers=RUNTIME_CHECK_MAX_WORKERS,
+                           max_check_workers=RUNTIME_DOWNLOAD_MAX_WORKERS) -> None:
+    """
+    Download runtime files from given component.
+    :param component: Target component of the java runtime (e.g. java-runtime-alpha, java-runtime-beta)
+    :param runtime_dir:
+    :param no_hash_check:
+    :param progress_callback:
+    :param redownload_callback:
+    :param max_download_workers:
+    :param max_check_workers:
+    :return:
+        None
+    """
+    # Fetch manifest
+    root_manifest = fetch_runtime_manifest()
+    manifest = get_support_runtime_manifest(root_manifest, component, no_hash_check=no_hash_check)
+    executables, files, dirs = collect_runtime_files(manifest, runtime_dir, max_workers=max_check_workers,
+                                                     no_hash_check=no_hash_check)
+
+    # Download runtime files
+    full_files = list(files)
+    full_files.extend(list(executables))
+    fails, successes = download_multiple_files(full_files, max_workers=max_download_workers,
+                                               progress_callback=progress_callback)
+
+    download_ok = len(fails) == 0
+
+    if fails and callable(redownload_callback):
+        download_ok, fails = redownload_callback(fails)
+
+    if not download_ok:
+        logger.warning(
+            "Download failed for runtime files: \n"
+            + "\n".join([asset.posix_path for asset in fails])
+        )
+        raise DownloadException(
+            "Unable to download some runtime files.\n"
+        )
+
+    handle_runtime_dir_and_executable_process(dirs, executables, max_workers=max_check_workers)
+
+    return

core_lib/unclassified.py

@@ -1,3 +1,3 @@
-
-
-
+"""
+This file is for a function that you don't know where to put it.
+"""

dialog/test.py

@@ -1,4 +1,5 @@
 import json
+import queue
 import subprocess
 import textwrap
 import threading
@@ -14,23 +15,46 @@ from core_lib.common.common import download_file, FileObject, download_multiple_
 from core_lib.common.exception import VersionNotSelectedException, UnsupportedPlatformException, \
     NativeResolveException, DownloadException, DependencyException, VersionManifestFetchException, \
     VersionManifestSaveException, NoSpecifiedVersionKeyException, AssetManifestFetchException, \
-    AssetManifestSaveException, AssetDataKeyNotFoundException
+    AssetManifestSaveException, AssetDataKeyNotFoundException, VersionDataKeyNotFoundException
 from core_lib.game.argument import ArgumentMappings, parse_and_generate_arguments, find_game_and_jvm_args, \
     generate_launch_command
-from core_lib.game.asset import fetch_and_save_asset_manifest, collect_assets_from_manifest, download_assets_and_copy
-from core_lib.game.library import collect_native_artifacts, download_libraries, unzip_natives, \
-    collect_library_artifacts, generate_classpath
+from core_lib.game.asset import download_assets
+from core_lib.game.library import generate_classpath, download_full_libraries
 
 from core_lib.game.version_info import (find_useful_part_in_specific_version_manifest,
                                         get_core_file_download_url_and_hash, \
                                         get_all_versions, get_available_version_types, \
-                                        fetch_and_save_version_manifest, get_specific_version_manifest_url_and_hash)
+                                        fetch_and_save_version_manifest, get_specific_version_manifest_url_and_hash,
+                                        download_core_file)
 from core_lib.qt import messagebox
 from core_lib.qt.hack import is_main_thread
+from core_lib.qt.messagebox import ask_yes_no_with_plain_text
 
 MAX_DOWNLOAD_ATTEMPTS = 3
 
 
+class YesNoRequest:
+    def __init__(self, title, message):
+        self.title = title
+        self.message = message
+        self.result_queue = queue.Queue(maxsize=1)
+        self.wait_event = threading.Event()
+
+        self.details = None # Set this if flag use_plain_text is enabled
+
+        # flags
+        self.use_plain_text = True
+
+    def wait(self, timeout: int | None = 10):
+        return self.wait_event.wait(timeout)
+
+    def result(self):
+        try:
+            return self.result_queue.get_nowait()
+        except queue.Empty:
+            return None
+
+
 class TestDialog(QDialog):
     def __init__(self, app, parent):
         super().__init__(parent)
@@ -220,30 +244,37 @@ class TestDialog(QDialog):
         show_info_message = Signal(str)
         enable_widget = Signal(object)
         disable_widget = Signal(object)
-        askyesno = Signal(dict)  # {"title", "targetEvent", "message", "result"}
+        askyesno = Signal(object)
         ask_for_path = Signal(dict)
         get_selected_ver = Signal(dict)
         get_selected_type = Signal(dict)
         clean_output = Signal()
 
-    @Slot(dict)
-    def ask_request(self, context: dict):
-        title = context.get("title", "Info")
-        message = context.get("message", "No content")
-        event = context.get("event", None)
-        msg = QMessageBox.question(
-            self,
-            title,
-            message,
-            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
-            QMessageBox.StandardButton.Yes,
-        )
+    @Slot(object)
+    def ask_request(self, context: YesNoRequest):
+        if not context.use_plain_text:
+            msg = QMessageBox.question(
+                self,
+                context.title,
+                context.message,
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                QMessageBox.StandardButton.Yes,
+            )
+            result = msg == QMessageBox.StandardButton.Yes
+        else:
+            result = ask_yes_no_with_plain_text(
+                self,
+                context.title,
+                context.message,
+                context.details,
+            )
 
-        if msg == QMessageBox.StandardButton.Yes and type(event) == threading.Event:
-            context["result"] = True
+        if result:
+            context.result_queue.put(True)
+        else:
+            context.result_queue.put(False)
 
-        if isinstance(event, threading.Event):
-            event.set()
+        context.wait_event.set()
 
     @Slot(dict)
     def get_selected_ver(self, context: dict):
@@ -595,11 +626,11 @@ class TestDialog(QDialog):
             data = fetch_and_save_version_manifest(path, target_version=specified_ver, root_manifest=root_manifest)
         except VersionManifestFetchException as e:
             self.widget_signal.show_error_message.emit(
-                "Unable to fetch version manifest: {}".format(e.user_message),
+                e.user_message,
             )
         except VersionManifestSaveException as e:
             self.widget_signal.show_error_message.emit(
-                "Unable to save version manifest: {}".format(e.user_message),
+                e.user_message,
             )
         except Exception as e:
             self.widget_signal.show_and_print_error_message.emit(
@@ -665,7 +696,7 @@ class TestDialog(QDialog):
                 self.app.logger.warning("Specified version '{}' hash doesn't exist.".format(specified_ver))
 
             # Also check sha1
-            if specified_ver and age < max_age and (sha1 is None or file.verify("sha1", sha1)):
+            if specified_ver and age < max_age and file.verify("sha1", sha1):
                 return self._read_cached_version_manifest(specified_ver)
 
         result, data = self._cache_version_manifest(specified_ver, root_manifest=root_manifest)
@@ -686,27 +717,22 @@ class TestDialog(QDialog):
             if not ver_data:
                 return
 
-            url, sha1 = get_core_file_download_url_and_hash(ver_data)
-
-            dest = Path(self.app.work_dir, "versions", ver, "client.jar")
-
-            file = FileObject(dest, url=url)
-
-            if sha1 is None:
-                self.app.logger.warning("Client has no sha1.")
-
-            if file.exists and file.verify("sha1", sha1):
-                self.download_signal.log.emit(f"Client existed and sha1 matches.")
-            elif url is not None:
-                download_file(file, progress_callback=self.download_signal.progress.emit)
-            elif not url:
-                self.download_signal.failed.emit("Download URL not found.")
-
-            self.download_signal.log.emit(f"Downloaded URL: {url}")
+            client_dest = Path(self.app.work_dir, "versions", ver, f"{ver}.jar")
+            download_core_file(ver_data, client_dest, progress_callback=self.download_signal.progress.emit,
+                               raise_for_null_hash=True)
+            self.download_signal.log.emit(f"Downloaded {ver} client to {client_dest}")
         except DownloadException as e:
             self.widget_signal.show_error_message.emit(
                 "Unable to download client while downloading it: {}".format(e.user_message),
             )
+        except VersionDataKeyNotFoundException as e:
+            self.widget_signal.show_and_print_error_message.emit(
+                {
+                    "error": traceback.format_exception(e),
+                    "title": "Fetch Error",
+                    "message": "Unable to download client due to some necessary key is missing.",
+                }
+            )
         except Exception as e:
             self.widget_signal.show_and_print_error_message.emit(
                 {
@@ -719,9 +745,6 @@ class TestDialog(QDialog):
             self.widget_signal.enable_widget.emit(self.button_2)
 
     def _download_libraries(self, ver: str):
-        output_dir = Path(self.app.work_dir, "libraries")
-        output_dir.mkdir(parents=True, exist_ok=True)
-
         try:
             self.widget_signal.clean_output.emit()
 
@@ -730,35 +753,21 @@ class TestDialog(QDialog):
             if not ver_data:
                 return
 
-            # libraries
-            libraries = collect_library_artifacts(ver_data)
+            libraries_dir = Path(self.app.work_dir, "libraries")
+            natives_dest = Path(self.app.work_dir, "versions", ver, "natives")
+            libraries_dir.mkdir(parents=True, exist_ok=True)
+            natives_dest.mkdir(parents=True, exist_ok=True)
 
-            # natives
-            natives = collect_native_artifacts(ver_data)
-
-            # all
-            full = list(libraries)
-            full.extend(natives)
-
-            self.download_signal.log.emit(
-                "Supported native count: {}".format(len(natives))
+            download_full_libraries(
+                ver_data,
+                libraries_dir,
+                natives_dest,
+                progress_callback=self.download_signal.progress.emit,
+                redownload_callback=self.redownload_files
+            )
+            self.download_signal.log.emit(
+                "All libraries downloaded successfully."
             )
-
-            # Start download
-            fails, successes = download_libraries(full, output_dir,
-                                                  progress_callback=self.download_signal.progress.emit)
-
-            download_ok, fails = self.redownload_files(fails)
-
-            if not download_ok:
-                self.widget_signal.show_error_message.emit(
-                    "Unable to continue process due to certain libraries download failed:\n"
-                    + "\n".join(file.posix_path for file in fails)
-                )
-            else:
-                # Start unzip natives
-                natives_dest = Path(self.app.work_dir, "versions", ver, "natives")
-                unzip_natives(natives, output_dir, natives_dest)
         except DependencyException as e:
             self.widget_signal.show_error_message.emit(
                 "Unable to collect library artifacts.\n"
@@ -799,38 +808,19 @@ class TestDialog(QDialog):
             if not ver_data:
                 return
 
-            _, asset_index, _, _, _, _, _ = find_useful_part_in_specific_version_manifest(ver_data)
-
-            asset_id = asset_index.get("id")
             assets_dir = Path(self.app.work_dir, "assets")
-            index_path = Path(assets_dir, "indexes", f"{asset_id}.json")
 
-            # Download and save asset manifest
-            asset_manifest = fetch_and_save_asset_manifest(
-                ver_data,
-                index_path,
-            )
-
-            # Download assets files
-            assets, legacy_assets = collect_assets_from_manifest(
-                asset_id,
-                asset_manifest,
-                assets_dir,
-            )
-
-            fails = download_assets_and_copy(
-                assets,
-                legacy_assets,
-                progress_callback=self.download_signal.progress.emit,
-            )
+            fails = download_assets(ver_data, assets_dir, no_hash_check=True)
 
             if fails:
-                self.widget_signal.show_error_message.emit(
-                    "Some assets failed to download:\n"
-                    + "\n".join(file.posix_path for file in fails)
+                self.widget_signal.show_warning_message.emit(
+                    "Some assets were not downloaded. Although is not necessary for launching game."
+                    " But it may cause some texture issue when you playing. (Such as missing textures)"
                 )
             else:
-                self.download_signal.log.emit("All necessary assets were downloaded.")
+                self.download_signal.log.emit(
+                    "All assets downloaded successfully."
+                )
         except AssetManifestFetchException as e:
             self.widget_signal.show_error_message.emit(
                 f"Unable to fetch asset manifest.\n{e.user_message}"
@@ -895,9 +885,22 @@ class TestDialog(QDialog):
             self.widget_signal.enable_widget.emit(self.button_6)
 
     def _launch_offline_game(self, ver, java_path):
+        """
+        Launch offline game
+        :param ver:
+        :param java_path:
+        :return:
+        """
         try:
+            current_status = 0 # 0 = fetch version manifest, 1 = check client, 2 = check libraries
+            # 3 = check libraries, 4 = check assets
+
+            # Version manifest
             ver_data = self.get_cached_version_manifest(ver)
 
+            if not ver_data:
+                return
+
             arguments, asset_index, downloads, java_version, libraries, main_class, old_args = (
                 find_useful_part_in_specific_version_manifest(ver_data)
             )
@@ -905,24 +908,65 @@ class TestDialog(QDialog):
             # Vars
             asset_id = asset_index.get("id")
 
-            # Download game files (ignore if exists)
-
-            # Client
-            self._download_client(ver)
-            self._download_libraries(ver)
-            self._download_assets(ver)
-
             # Some paths
+            core_file_path = Path(self.app.work_dir, "versions", ver, f"{ver}.jar")
             game_dir = Path(self.app.temp_dir, "minecraft")
             game_dir.mkdir(parents=True, exist_ok=True)
             natives_dir = Path(self.app.work_dir, "versions", ver, "natives")
             assets_dir = Path(self.app.work_dir, "assets")
             libraries_dir = Path(self.app.work_dir, "libraries")
 
+            # Check client
+            self._download_client(ver)
+
+            if not core_file_path.exists():
+                url, sha1 = get_core_file_download_url_and_hash(ver_data)
+
+            try:
+                ver_data = self.get_cached_version_manifest(ver)
+
+                if not ver_data:
+                    return
+
+                url, sha1 = get_core_file_download_url_and_hash(ver_data)
+
+                dest = Path(self.app.work_dir, "versions", ver, f"{ver}.jar")
+
+                file = FileObject(dest, url=url)
+
+                if sha1 is None:
+                    self.app.logger.warning("Client has no sha1.")
+
+                if file.exists and file.verify("sha1", sha1):
+                    self.download_signal.log.emit(f"Client existed and sha1 matches.")
+                elif url is not None:
+                    download_file(file, progress_callback=self.download_signal.progress.emit)
+                elif not url:
+                    self.download_signal.failed.emit("Download URL not found.")
+
+                self.download_signal.log.emit(f"Downloaded URL: {url}")
+            except DownloadException as e:
+                self.widget_signal.show_error_message.emit(
+                    "Unable to download client while downloading it: {}".format(e.user_message),
+                )
+            except Exception as e:
+                self.widget_signal.show_and_print_error_message.emit(
+                    {
+                        "error": traceback.format_exception(e),
+                        "title": "Download Error",
+                        "message": "Unable to download client, an unexpected error occurred."
+                    }
+                )
+            finally:
+                self.widget_signal.enable_widget.emit(self.button_2)
+
+            self._download_libraries(ver)
+            self._download_assets(ver)
+
             classpath = generate_classpath(
                 ver_data,
-                Path(self.app.work_dir, "libraries"),
-                Path(self.app.work_dir, "versions", ver, "client.jar"),
+                libraries_dir,
+                core_file_path,
             )
 
             # Mappings
@@ -993,24 +1037,22 @@ class TestDialog(QDialog):
         message = (
                 "Some files failed to download.\n"
                 "Would you like to retry downloading them?\n\n"
-                + "\n".join(file.posix_path for file in files)
         )
-        ask_event = threading.Event()
-        context = {
-            "event": ask_event,
-            "title": "Retry downloading",
-            "message": message,
-        }
 
-        self.widget_signal.askyesno.emit(context)
+        request = YesNoRequest("Redownload", message)
+        request.details = "\n".join(file.posix_path for file in files)
 
-        if not ask_event.wait(60):
+        self.widget_signal.askyesno.emit(request)
+
+        if not request.wait(60):
             self.widget_signal.show_error_message.emit(
                 "Timed out while waiting for confirmation. Please try again."
             )
             return False, files
 
-        if not context.get("result", False):
+        result = request.result()
+
+        if not result:
             return False, files
 
         # copy