Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(java): Download JDK, and one-click "Download JDK N" where a JDK is missing (#61)

l0ng-ai56fdc005a890
diff --git a/crates/ide-sdk/src/discover.rs b/crates/ide-sdk/src/discover.rs
index 903682d31..439971472 100644
--- a/crates/ide-sdk/src/discover.rs
+++ b/crates/ide-sdk/src/discover.rs
@@ -394,27 +394,33 @@ fn release_value(release: &str, key: &str) -> Option<String> {
}
fn jdk() -> Vec<Sdk> {
+ crate::java::rescan_jdks().iter().map(jdk_sdk).collect()
+}
+
+/// A JDK as the SDK pickers list it (`Eclipse Adoptium 25.0.1`).
+pub fn jdk_sdk(j: &crate::java::Jdk) -> Sdk {
let java_home = std::env::var_os("JAVA_HOME").and_then(|h| dunce::canonicalize(h).ok());
- crate::java::rescan_jdks()
- .iter()
- .map(|j| {
- let release = std::fs::read_to_string(j.home.join("release")).unwrap_or_default();
- let version = release_value(&release, "JAVA_VERSION").unwrap_or_else(|| j.major.to_string());
- let name = match release_value(&release, "IMPLEMENTOR") {
- Some(vendor) => format!("{vendor} {version}"),
- None => format!("JDK {version}"),
- };
- let source = if java_home.as_ref() == Some(&j.home) { "JAVA_HOME" } else { "system" };
- Sdk {
- path: j.home.clone().into(),
- name,
- version: Some(version),
- source: source.to_owned(),
- home: Some(j.home.clone().into()),
- extra: None,
- }
- })
- .collect()
+ let release = std::fs::read_to_string(j.home.join("release")).unwrap_or_default();
+ let version = release_value(&release, "JAVA_VERSION").unwrap_or_else(|| j.major.to_string());
+ let name = match release_value(&release, "IMPLEMENTOR") {
+ Some(vendor) => format!("{vendor} {version}"),
+ None => format!("JDK {version}"),
+ };
+ let source = if java_home.as_ref() == Some(&j.home) {
+ "JAVA_HOME"
+ } else if crate::java::is_downloaded(&j.home) {
+ "downloaded"
+ } else {
+ "system"
+ };
+ Sdk {
+ path: j.home.clone().into(),
+ name,
+ version: Some(version),
+ source: source.to_owned(),
+ home: Some(j.home.clone().into()),
+ extra: None,
+ }
}
// ------------------------------------------------------------------ maven
diff --git a/crates/ide-sdk/src/java.rs b/crates/ide-sdk/src/java.rs
index c021612c9..163427cb1 100644
--- a/crates/ide-sdk/src/java.rs
+++ b/crates/ide-sdk/src/java.rs
@@ -49,9 +49,26 @@ fn children(dir: &Path) -> Vec<PathBuf> {
const WINDOWS_VENDORS: &[&str] =
&["Java", "Eclipse Adoptium", "Microsoft", "Zulu", "Amazon Corretto", "BellSoft", "Semeru", "OpenJDK"];
+/// Folders the IDE downloads JDKs into ([`add_jdk_root`]).
+static EXTRA_ROOTS: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
+
+/// Scans the JDKs in `dir` (one per subfolder) too, e.g. where Download JDK puts them.
+pub fn add_jdk_root(dir: &Path) {
+ let mut roots = EXTRA_ROOTS.lock().unwrap_or_else(|e| e.into_inner());
+ if !roots.iter().any(|r| r == dir) {
+ roots.push(dir.to_path_buf());
+ }
+}
+
+/// Whether `home` lies in a folder registered with [`add_jdk_root`].
+pub fn is_downloaded(home: &Path) -> bool {
+ let roots = EXTRA_ROOTS.lock().unwrap_or_else(|e| e.into_inner());
+ roots.iter().any(|r| home.starts_with(r) || dunce::canonicalize(r).is_ok_and(|r| home.starts_with(r)))
+}
+
/// JDK homes in the usual install locations (macOS `JavaVirtualMachines`,
/// `/usr/lib/jvm`, SDKMAN, IDEA's `~/.jdks`, Homebrew, Windows vendor
-/// directories), `JAVA_HOME` first, then the `java` on `PATH`.
+/// directories, the IDE's downloads), `JAVA_HOME` first, then the `java` on `PATH`.
fn scan() -> Vec<Jdk> {
let mut homes: Vec<PathBuf> = Vec::new();
if let Some(h) = std::env::var_os("JAVA_HOME") {
@@ -74,6 +91,7 @@ fn scan() -> Vec<Jdk> {
if let Some(h) = &home {
roots.extend([h.join("Library/Java/JavaVirtualMachines"), h.join(".jdks"), h.join(".sdkman/candidates/java")]);
}
+ roots.extend(EXTRA_ROOTS.lock().unwrap_or_else(|e| e.into_inner()).iter().cloned());
if cfg!(windows) {
let bases = ["ProgramFiles", "ProgramW6432", "LOCALAPPDATA"].into_iter().filter_map(|v| {
let dir = PathBuf::from(std::env::var_os(v)?);
@@ -346,32 +364,51 @@ pub fn configure_jdtls(
/// Where the JDK that runs jdtls is chosen, named as the settings dialog shows it.
const SERVER_JDK_SETTING: &str = "Settings › Languages & Frameworks › Java › Language Server › JDK";
-fn missing_runtime_message(jdks: &[Jdk], min_java: u32) -> String {
+/// `found JDK 8, 17` / `no JDK was found`.
+fn found_jdks(jdks: &[Jdk]) -> String {
let mut found: Vec<u32> = jdks.iter().map(|j| j.major).collect();
found.sort_unstable();
found.dedup();
- let found = if found.is_empty() {
+ if found.is_empty() {
"no JDK was found".to_owned()
} else {
let list: Vec<String> = found.iter().map(u32::to_string).collect();
format!("found JDK {}", list.join(", "))
- };
+ }
+}
+
+// The UI offers "Download JDK N" for messages saying "needs JDK N or newer".
+fn missing_runtime_message(jdks: &[Jdk], min_java: u32) -> String {
format!(
- "jdtls needs JDK {min_java} or newer to run ({found}). Pick one in {SERVER_JDK_SETTING} (it restarts \
- automatically), or install a newer JDK and restart the server; the project can still target an older \
- Java version."
+ "jdtls needs JDK {min_java} or newer to run ({}). Download JDK {min_java}, or pick an installed one in \
+ {SERVER_JDK_SETTING} (it restarts automatically); the project can still target an older Java version.",
+ found_jdks(jdks)
)
}
fn server_jdk_too_old_message(jdk: &Jdk, min_java: u32) -> String {
format!(
- "The language server JDK ({}, JDK {}) is too old: jdtls needs JDK {min_java} or newer. Choose another \
- one in {SERVER_JDK_SETTING}, or set it to Auto.",
+ "The language server JDK ({}, JDK {}) is too old: jdtls needs JDK {min_java} or newer. Download JDK \
+ {min_java}, choose another one in {SERVER_JDK_SETTING}, or set it to Auto.",
jdk.home.display(),
jdk.major
)
}
+/// Why a module targeting Java `release` can't be built or run with the installed
+/// JDKs (none is that new), or `None` when one is (or the release is unknown).
+pub fn missing_jdk_message(jdks: &[Jdk], release: Option<u32>) -> Option<String> {
+ let release = release?;
+ if jdks.iter().any(|j| j.major >= release) {
+ return None;
+ }
+ Some(format!(
+ "This project targets Java {release}: it needs JDK {release} or newer ({}). Download JDK {release}, or \
+ choose a Project JDK in Settings › Languages & Frameworks › Java.",
+ found_jdks(jdks)
+ ))
+}
+
/// The `java` launcher of a JDK home.
pub fn java_executable(home: &Path) -> PathBuf {
home.join("bin").join(crate::exe("java"))
@@ -595,6 +632,62 @@ mod tests {
configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &mixed, None, None, 25, &[], None);
let err = cfg.launch_error.unwrap();
assert!(err.contains("JDK 25 or newer") && err.contains("found JDK 17, 21"), "{err}");
+ assert!(err.contains("Download JDK 25"), "offers the download: {err}");
+ }
+
+ #[test]
+ fn issue_49_jdtls_needs_25_with_8_17_21_installed() {
+ let jdtls = || -> LanguageServerConfig { toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap() };
+ let installed = [
+ Jdk { major: 21, home: PathBuf::from("/jdk21") },
+ Jdk { major: 17, home: PathBuf::from("/jdk17") },
+ Jdk { major: 8, home: PathBuf::from("/jdk8") },
+ ];
+ let mut cfg = jdtls();
+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &installed, None, None, 25, &[], None);
+ let err = cfg.launch_error.unwrap();
+ assert!(err.starts_with("jdtls needs JDK 25 or newer to run (found JDK 8, 17, 21)"), "{err}");
+ assert!(err.contains("Download JDK 25"), "{err}");
+
+ // Once a JDK 25 has been downloaded, Auto runs jdtls on it.
+ let downloaded =
+ [installed.as_slice(), &[Jdk { major: 25, home: PathBuf::from("/tools/jdks/temurin-25") }]].concat();
+ let mut cfg = jdtls();
+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &downloaded, None, None, 25, &[], None);
+ assert_eq!(cfg.launch_error, None);
+ assert_eq!(cfg.env["JAVA_HOME"], Path::new("/tools/jdks/temurin-25").to_string_lossy());
+ }
+
+ #[test]
+ fn missing_jdk_for_the_project_release() {
+ let jdks = [Jdk { major: 17, home: PathBuf::from("/jdk17") }, Jdk { major: 8, home: PathBuf::from("/jdk8") }];
+ assert_eq!(missing_jdk_message(&jdks, Some(17)), None);
+ assert_eq!(missing_jdk_message(&jdks, Some(11)), None);
+ assert_eq!(missing_jdk_message(&jdks, None), None);
+ let msg = missing_jdk_message(&jdks, Some(21)).unwrap();
+ assert!(msg.contains("needs JDK 21 or newer (found JDK 8, 17)") && msg.contains("Download JDK 21"), "{msg}");
+ assert!(missing_jdk_message(&[], Some(8)).unwrap().contains("no JDK was found"));
+ }
+
+ #[test]
+ fn downloaded_jdks_are_found() {
+ let tmp = tempfile::tempdir().unwrap();
+ let home = tmp.path().join("jdks/temurin-25.0.1");
+ std::fs::create_dir_all(home.join("bin")).unwrap();
+ std::fs::write(home.join("release"), "JAVA_VERSION=\"25.0.1\"\n").unwrap();
+ std::fs::write(home.join("bin").join(crate::exe("java")), "").unwrap();
+ // macOS bundles: <dir>/Contents/Home
+ let bundle = tmp.path().join("jdks/temurin-21.0.5/Contents/Home");
+ std::fs::create_dir_all(bundle.join("bin")).unwrap();
+ std::fs::write(bundle.join("release"), "JAVA_VERSION=\"21.0.5\"\n").unwrap();
+ std::fs::write(bundle.join("bin").join(crate::exe("java")), "").unwrap();
+ add_jdk_root(&tmp.path().join("jdks"));
+ let found = rescan_jdks();
+ let home = dunce::canonicalize(&home).unwrap();
+ let bundle = dunce::canonicalize(&bundle).unwrap();
+ assert!(found.iter().any(|j| j.home == home && j.major == 25), "{found:?}");
+ assert!(found.iter().any(|j| j.home == bundle && j.major == 21), "{found:?}");
+ assert!(is_downloaded(&home) && !is_downloaded(Path::new("/elsewhere")));
}
#[test]
diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rs
index 95651dd42..8660e9d52 100644
--- a/crates/ide-sdk/src/lib.rs
+++ b/crates/ide-sdk/src/lib.rs
@@ -19,7 +19,7 @@ use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::{Path, PathBuf};
-pub use discover::detect;
+pub use discover::{detect, jdk_sdk};
pub use exec::search_path;
/// What [`detect`] looks for.
diff --git a/crates/ide-sdk/src/locate.rs b/crates/ide-sdk/src/locate.rs
index d01005fcc..22717b59c 100644
--- a/crates/ide-sdk/src/locate.rs
+++ b/crates/ide-sdk/src/locate.rs
@@ -85,7 +85,11 @@ pub fn locate_tools_in(names: &[String], near: Option<&Path>, search: &std::ffi:
.iter()
.map(|name| {
let path = valid_name(name)
- .then(|| near.and_then(|n| local_bin(n, name)).or_else(|| on_path(name, search)))
+ .then(|| {
+ near.and_then(|n| local_bin(n, name))
+ .or_else(|| on_path(name, search))
+ .or_else(|| jdk_tool(name, &crate::java::installed_jdks()))
+ })
.flatten();
LocatedTool { name: name.clone(), path: path.map(Into::into), version: None }
})
@@ -106,6 +110,16 @@ pub fn locate_tools_in(names: &[String], near: Option<&Path>, search: &std::ffi:
})
}
+/// `java` / `javac` / `jshell` of the newest installed JDK when none is on the
+/// search path (JDKs installed without `PATH` changes, or downloaded by the IDE).
+fn jdk_tool(name: &str, jdks: &[crate::java::Jdk]) -> Option<PathBuf> {
+ if !["java", "javac", "jshell"].contains(&name) {
+ return None;
+ }
+ let jdk = jdks.iter().max_by_key(|j| j.major)?;
+ Some(jdk.home.join("bin").join(crate::exe(name))).filter(|p| p.is_file())
+}
+
/// Directory for binaries compiled from single source files (`rustc`, `clang`).
pub fn compile_dir() -> PathBuf {
std::env::temp_dir().join("openidea-run")
@@ -124,6 +138,26 @@ mod tests {
assert_eq!(parse_tool_version("no version here"), None);
}
+ #[test]
+ fn java_falls_back_to_the_newest_installed_jdk() {
+ let tmp = tempfile::tempdir().unwrap();
+ let jdk = |major: u32| {
+ let home = tmp.path().join(format!("jdk{major}"));
+ std::fs::create_dir_all(home.join("bin")).unwrap();
+ for t in ["java", "javac"] {
+ std::fs::write(home.join("bin").join(crate::exe(t)), "").unwrap();
+ }
+ crate::java::Jdk { major, home }
+ };
+ let jdks = [jdk(17), jdk(25), jdk(21)];
+ let newest = tmp.path().join("jdk25/bin");
+ assert_eq!(jdk_tool("java", &jdks), Some(newest.join(crate::exe("java"))));
+ assert_eq!(jdk_tool("javac", &jdks), Some(newest.join(crate::exe("javac"))));
+ assert_eq!(jdk_tool("jshell", &jdks), None, "not in this JDK");
+ assert_eq!(jdk_tool("node", &jdks), None);
+ assert_eq!(jdk_tool("java", &[]), None);
+ }
+
#[test]
fn rejects_paths_and_shell_syntax() {
assert!(valid_name("ts-node"));
diff --git a/crates/ide-tools/src/jdk.rs b/crates/ide-tools/src/jdk.rs
new file mode 100644
index 000000000..d93212f6d
--- /dev/null
+++ b/crates/ide-tools/src/jdk.rs
@@ -0,0 +1,477 @@
+//! JDK downloads (IDEA's Download JDK): Eclipse Temurin builds from the
+//! Adoptium API, unpacked into `<tools>/jdks/<vendor>-<version>` (or a chosen
+//! location) where JDK discovery finds them. Parsing is pure so it is testable
+//! without network.
+
+use crate::platform::{Arch, Os, Platform};
+use crate::process::{Emit, Http};
+use crate::sources::Download;
+use crate::{InstallEvent, InstallGuard, Tools, archive, clear_quarantine, fetch_verified};
+use ide_core::error::ErrorKind;
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::path::{Path, PathBuf};
+
+const ADOPTIUM_API: &str = "https://api.adoptium.net/v3";
+
+/// A JDK distribution the IDE can download.
+#[derive(Clone, Debug, PartialEq, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct JdkVendor {
+ pub id: String,
+ pub name: String,
+}
+
+pub const TEMURIN: &str = "temurin";
+
+pub fn vendors() -> Vec<JdkVendor> {
+ vec![JdkVendor { id: TEMURIN.into(), name: "Eclipse Temurin".into() }]
+}
+
+/// Java versions a vendor publishes.
+#[derive(Clone, Debug, PartialEq, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct JdkReleases {
+ /// Feature versions, newest first.
+ pub versions: Vec<u32>,
+ /// The long-term-support ones among them.
+ pub lts: Vec<u32>,
+ /// The version offered first (the newest LTS).
+ pub recommended: u32,
+}
+
+/// A JDK the IDE downloaded.
+#[derive(Clone, Debug, PartialEq, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct DownloadedJdk {
+ pub home: ide_core::IpcPath,
+ /// Full version, e.g. `25.0.1`.
+ pub version: String,
+ pub major: u32,
+}
+
+/// Where downloaded JDKs go by default.
+pub fn jdks_dir(app_data: &Path) -> PathBuf {
+ crate::tools_dir(app_data).join("jdks")
+}
+
+fn proto(msg: impl Into<String>) -> IdeError {
+ IdeError::new(ErrorKind::Protocol, msg)
+}
+
+fn vendor_or_err(vendor: &str) -> IdeResult<()> {
+ if vendor == TEMURIN { Ok(()) } else { Err(IdeError::invalid(format!("unknown JDK vendor `{vendor}`"))) }
+}
+
+pub fn adoptium_releases_url() -> String {
+ format!("{ADOPTIUM_API}/info/available_releases")
+}
+
+#[derive(Deserialize)]
+struct AvailableReleases {
+ available_releases: Vec<u32>,
+ #[serde(default)]
+ available_lts_releases: Vec<u32>,
+ #[serde(default)]
+ most_recent_lts: Option<u32>,
+}
+
+pub fn parse_releases(json: &str) -> IdeResult<JdkReleases> {
+ let r: AvailableReleases =
+ serde_json::from_str(json).map_err(|e| proto(format!("unexpected Adoptium response: {e}")))?;
+ let mut versions = r.available_releases;
+ versions.sort_unstable_by(|a, b| b.cmp(a));
+ versions.dedup();
+ let recommended = r
+ .most_recent_lts
+ .or_else(|| r.available_lts_releases.iter().copied().max())
+ .or_else(|| versions.first().copied())
+ .ok_or_else(|| proto("Adoptium lists no Java versions"))?;
+ Ok(JdkReleases { versions, lts: r.available_lts_releases, recommended })
+}
+
+fn adoptium_os(os: Os) -> &'static str {
+ match os {
+ Os::Mac => "mac",
+ Os::Linux => "linux",
+ Os::Windows => "windows",
+ }
+}
+
+fn adoptium_arch(arch: Arch) -> &'static str {
+ match arch {
+ Arch::X64 => "x64",
+ Arch::Arm64 => "aarch64",
+ }
+}
+
+/// The latest Temurin JDK build of Java `feature` for `platform`.
+pub fn adoptium_assets_url(feature: u32, platform: Platform) -> String {
+ format!(
+ "{ADOPTIUM_API}/assets/latest/{feature}/hotspot?architecture={}&image_type=jdk&os={}&vendor=eclipse",
+ adoptium_arch(platform.arch),
+ adoptium_os(platform.os),
+ )
+}
+
+#[derive(Deserialize)]
+struct Asset {
+ binary: Binary,
+ version: AssetVersion,
+}
+
+#[derive(Deserialize)]
+struct Binary {
+ #[serde(default)]
+ image_type: Option<String>,
+ #[serde(default)]
+ heap_size: Option<String>,
+ #[serde(default)]
+ os: Option<String>,
+ package: Package,
+}
+
+#[derive(Deserialize)]
+struct Package {
+ name: String,
+ link: String,
+ #[serde(default)]
+ checksum: Option<String>,
+ #[serde(default)]
+ size: Option<u64>,
+}
+
+#[derive(Deserialize)]
+struct AssetVersion {
+ major: u32,
+ #[serde(default)]
+ minor: u32,
+ #[serde(default)]
+ security: u32,
+ #[serde(default)]
+ openjdk_version: Option<String>,
+}
+
+impl AssetVersion {
+ /// `25.0.1` (`openjdk_version` without its build; `1.8.0_472` style for Java 8).
+ fn display(&self) -> String {
+ let plain = || format!("{}.{}.{}", self.major, self.minor, self.security);
+ match &self.openjdk_version {
+ Some(v) => {
+ let v = v.split(['+', '-']).next().unwrap_or(v);
+ if v.is_empty() { plain() } else { v.to_owned() }
+ }
+ None => plain(),
+ }
+ }
+}
+
+/// The JDK archive (`.tar.gz` on macOS / Linux, `.zip` on Windows) in an Adoptium
+/// `assets/latest` response; `None` when there is no build for the platform.
+pub fn adoptium_pick(json: &str, platform: Platform) -> IdeResult<Option<(Download, u32)>> {
+ let assets: Vec<Asset> =
+ serde_json::from_str(json).map_err(|e| proto(format!("unexpected Adoptium response: {e}")))?;
+ let ext = if platform.os == Os::Windows { ".zip" } else { ".tar.gz" };
+ let os = adoptium_os(platform.os);
+ let found = assets.into_iter().find(|a| {
+ a.binary.image_type.as_deref().is_none_or(|t| t == "jdk")
+ && a.binary.heap_size.as_deref().is_none_or(|h| h == "normal")
+ && a.binary.os.as_deref().is_none_or(|o| o == os)
+ && a.binary.package.name.ends_with(ext)
+ });
+ Ok(found.map(|a| {
+ let sha256 = a.binary.package.checksum.map(|c| c.trim().to_ascii_lowercase()).filter(|c| c.len() == 64);
+ (
+ Download {
+ version: a.version.display(),
+ name: a.binary.package.name,
+ url: a.binary.package.link,
+ size: a.binary.package.size,
+ sha256,
+ checksum_url: None,
+ },
+ a.version.major,
+ )
+ }))
+}
+
+/// Folder name of a downloaded JDK, as IDEA names them: `temurin-25.0.1`.
+pub fn jdk_dir_name(vendor: &str, version: &str) -> String {
+ let safe: String =
+ version.chars().map(|c| if c.is_ascii_alphanumeric() || matches!(c, '.' | '_') { c } else { '-' }).collect();
+ format!("{vendor}-{safe}")
+}
+
+fn is_jdk_home(dir: &Path, platform: Platform) -> bool {
+ dir.join("release").is_file() && dir.join("bin").join(platform.exe("java")).is_file()
+}
+
+/// The JDK home inside an unpacked JDK: `dir` itself, `dir/Contents/Home`
+/// (a macOS bundle), or either of those below one top-level folder
+/// (`jdk-25.0.1+8/`, `jdk-25.0.1+8/Contents/Home`).
+pub fn find_jdk_home(dir: &Path, platform: Platform) -> Option<PathBuf> {
+ let candidates = |d: &Path| [d.to_path_buf(), d.join("Contents").join("Home")];
+ if let Some(home) = candidates(dir).into_iter().find(|h| is_jdk_home(h, platform)) {
+ return Some(home);
+ }
+ let mut subdirs: Vec<PathBuf> = std::fs::read_dir(dir)
+ .ok()?
+ .flatten()
+ .filter(|e| e.file_type().is_ok_and(|t| t.is_dir()))
+ .map(|e| e.path())
+ .collect();
+ subdirs.sort();
+ subdirs.iter().flat_map(|d| candidates(d)).find(|h| is_jdk_home(h, platform))
+}
+
+/// The directory to move into place: the archive's single top-level folder
+/// holding the JDK, else everything that was unpacked.
+fn unpacked_root(pkg: &Path, home: &Path) -> PathBuf {
+ match home.strip_prefix(pkg).ok().and_then(|rel| rel.components().next()) {
+ Some(first) if first.as_os_str() != "Contents" => pkg.join(first),
+ _ => pkg.to_path_buf(),
+ }
+}
+
+impl Tools {
+ fn http(&self) -> IdeResult<Http> {
+ Http::new(&self.system_path)
+ }
+
+ /// Java versions `vendor` publishes.
+ pub fn jdk_releases(&self, vendor: &str, cancel: &CancellationToken) -> IdeResult<JdkReleases> {
+ vendor_or_err(vendor)?;
+ parse_releases(&self.http()?.get_text(&adoptium_releases_url(), cancel)?)
+ }
+
+ /// Downloads the latest `vendor` JDK of Java `feature` into
+ /// `<location>/<vendor>-<version>` (`location` defaults to the tools' `jdks`
+ /// folder), verifying its SHA-256. A JDK already there is reused.
+ pub fn download_jdk(
+ &self,
+ vendor: &str,
+ feature: u32,
+ location: Option<&Path>,
+ cancel: &CancellationToken,
+ emit: Emit,
+ ) -> IdeResult<DownloadedJdk> {
+ vendor_or_err(vendor)?;
+ let _guard = InstallGuard::acquire(&format!("jdk-{vendor}-{feature}"))?;
+ let http = self.http()?;
+ let location = location.map(Path::to_path_buf).unwrap_or_else(|| self.root.join("jdks"));
+ emit(InstallEvent::Line { text: format!("Resolving the latest Eclipse Temurin {feature}…") });
+ let mut picked =
+ adoptium_pick(&http.get_text(&adoptium_assets_url(feature, self.platform), cancel)?, self.platform)?;
+ if picked.is_none() && self.platform.os == Os::Mac && self.platform.arch == Arch::Arm64 {
+ // Java 8 has no Apple Silicon build: the Intel one runs under Rosetta.
+ let intel = Platform { os: Os::Mac, arch: Arch::X64 };
+ picked = adoptium_pick(&http.get_text(&adoptium_assets_url(feature, intel), cancel)?, intel)?;
+ }
+ let (dl, major) = picked.ok_or_else(|| {
+ IdeError::unavailable(format!(
+ "Eclipse Temurin {feature} has no build for {:?} {:?}",
+ self.platform.os, self.platform.arch
+ ))
+ })?;
+ let target = location.join(jdk_dir_name(vendor, &dl.version));
+ let done = |home: PathBuf| DownloadedJdk { home: home.into(), version: dl.version.clone(), major };
+ if let Some(home) = find_jdk_home(&target, self.platform) {
+ emit(InstallEvent::Line { text: format!("{} is already installed", target.display()) });
+ return Ok(done(home));
+ }
+ emit(InstallEvent::Line { text: format!("Downloading {} ({})", dl.name, dl.url) });
+ std::fs::create_dir_all(&location)?;
+ // Next to the target, so moving it into place never crosses file systems.
+ let staging = location.join(format!(".staging-{}", jdk_dir_name(vendor, &dl.version)));
+ let _ = std::fs::remove_dir_all(&staging);
+ std::fs::create_dir_all(&staging)?;
+ let result = (|| {
+ let archive = fetch_verified(&http, &dl, &staging, cancel, emit)?;
+ emit(InstallEvent::Line { text: "Extracting…".into() });
+ let pkg = staging.join("pkg");
+ archive::extract(&archive, archive::ArchiveKind::from_name(&dl.name), &pkg, "java")?;
+ let home = find_jdk_home(&pkg, self.platform)
+ .ok_or_else(|| IdeError::new(ErrorKind::Io, format!("no JDK found in {}", dl.name)))?;
+ if target.exists() {
+ std::fs::remove_dir_all(&target)?;
+ }
+ std::fs::rename(unpacked_root(&pkg, &home), &target)?;
+ clear_quarantine(&target);
+ find_jdk_home(&target, self.platform)
+ .ok_or_else(|| IdeError::new(ErrorKind::Io, format!("no JDK found in {}", target.display())))
+ })();
+ let _ = std::fs::remove_dir_all(&staging);
+ let home = result?;
+ emit(InstallEvent::Line { text: format!("Eclipse Temurin {} installed in {}", dl.version, home.display()) });
+ Ok(done(home))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const MAC_ARM: Platform = Platform { os: Os::Mac, arch: Arch::Arm64 };
+ const LINUX_X64: Platform = Platform { os: Os::Linux, arch: Arch::X64 };
+ const WIN_X64: Platform = Platform { os: Os::Windows, arch: Arch::X64 };
+
+ #[test]
+ fn releases() {
+ let json = r#"{"available_lts_releases":[8,11,17,21,25],"available_releases":[8,11,16,17,21,24,25,26],
+ "most_recent_feature_release":26,"most_recent_lts":25,"tip_version":27}"#;
+ let r = parse_releases(json).unwrap();
+ assert_eq!(r.versions, [26, 25, 24, 21, 17, 16, 11, 8]);
+ assert_eq!(r.lts, [8, 11, 17, 21, 25]);
+ assert_eq!(r.recommended, 25);
+ assert!(parse_releases("{}").is_err());
+ }
+
+ #[test]
+ fn asset_urls() {
+ assert_eq!(
+ adoptium_assets_url(25, MAC_ARM),
+ "https://api.adoptium.net/v3/assets/latest/25/hotspot?architecture=aarch64&image_type=jdk&os=mac&vendor=eclipse"
+ );
+ assert_eq!(
+ adoptium_assets_url(21, WIN_X64),
+ "https://api.adoptium.net/v3/assets/latest/21/hotspot?architecture=x64&image_type=jdk&os=windows&vendor=eclipse"
+ );
+ assert!(adoptium_assets_url(17, LINUX_X64).contains("os=linux"));
+ }
+
+ fn asset(name: &str, os: &str, heap: &str, checksum: &str) -> String {
+ format!(
+ r#"{{"binary":{{"architecture":"x64","heap_size":"{heap}","image_type":"jdk","os":"{os}",
+ "installer":{{"name":"x.msi","link":"https://e/x.msi","checksum":"00"}},
+ "package":{{"name":"{name}","link":"https://e/{name}","checksum":"{checksum}","size":1234}}}},
+ "release_name":"jdk-25.0.1+8","vendor":"eclipse",
+ "version":{{"major":25,"minor":0,"security":1,"build":8,"openjdk_version":"25.0.1+8-LTS"}}}}"#
+ )
+ }
+
+ #[test]
+ fn picks_the_platform_archive() {
+ let sum = "36DC14D797AAFF6D89AAB302CD053FDBA6207DFDCF772052FA7B023A94B0E857";
+ let json = format!(
+ "[{},{},{}]",
+ asset("OpenJDK25U-jdk_x64_windows_hotspot_25.0.1_8.zip", "windows", "large", sum),
+ asset("OpenJDK25U-jdk_x64_windows_hotspot_25.0.1_8.zip", "windows", "normal", sum),
+ asset("OpenJDK25U-jdk_x64_linux_hotspot_25.0.1_8.tar.gz", "linux", "normal", sum),
+ );
+ let (dl, major) = adoptium_pick(&json, WIN_X64).unwrap().unwrap();
+ assert_eq!(dl.name, "OpenJDK25U-jdk_x64_windows_hotspot_25.0.1_8.zip");
+ assert_eq!(dl.url, "https://e/OpenJDK25U-jdk_x64_windows_hotspot_25.0.1_8.zip");
+ assert_eq!(dl.sha256.as_deref(), Some(sum.to_ascii_lowercase().as_str()));
+ assert_eq!((dl.version.as_str(), major, dl.size), ("25.0.1", 25, Some(1234)));
+ let (dl, _) = adoptium_pick(&json, LINUX_X64).unwrap().unwrap();
+ assert!(dl.name.ends_with(".tar.gz"));
+ // No build for the platform (Java 8 on Apple Silicon): an empty list.
+ assert_eq!(adoptium_pick("[]", MAC_ARM).unwrap(), None);
+ assert_eq!(adoptium_pick(&json, MAC_ARM).unwrap(), None);
+ assert!(adoptium_pick("{\"errorMessage\":\"x\"}", MAC_ARM).is_err());
+ }
+
+ #[test]
+ fn java_8_versions_and_dir_names() {
+ let v = AssetVersion { major: 8, minor: 0, security: 472, openjdk_version: Some("1.8.0_472-b08".into()) };
+ assert_eq!(v.display(), "1.8.0_472");
+ let v = AssetVersion { major: 21, minor: 0, security: 9, openjdk_version: None };
+ assert_eq!(v.display(), "21.0.9");
+ assert_eq!(jdk_dir_name(TEMURIN, "25.0.1"), "temurin-25.0.1");
+ assert_eq!(jdk_dir_name(TEMURIN, "1.8.0_472"), "temurin-1.8.0_472");
+ }
+
+ fn fake_jdk(home: &Path, platform: Platform) {
+ std::fs::create_dir_all(home.join("bin")).unwrap();
+ std::fs::write(home.join("release"), "JAVA_VERSION=\"25.0.1\"\n").unwrap();
+ std::fs::write(home.join("bin").join(platform.exe("java")), "").unwrap();
+ }
+
+ #[test]
+ fn finds_the_home_of_each_archive_layout() {
+ let tmp = tempfile::tempdir().unwrap();
+ // macOS: jdk-25.0.1+8/Contents/Home
+ let mac = tmp.path().join("mac");
+ fake_jdk(&mac.join("jdk-25.0.1+8/Contents/Home"), MAC_ARM);
+ std::fs::create_dir_all(mac.join("jdk-25.0.1+8/Contents/MacOS")).unwrap();
+ let home = find_jdk_home(&mac, MAC_ARM).unwrap();
+ assert_eq!(home, mac.join("jdk-25.0.1+8/Contents/Home"));
+ assert_eq!(unpacked_root(&mac, &home), mac.join("jdk-25.0.1+8"));
+ // Once moved into place, the bundle itself.
+ assert_eq!(find_jdk_home(&mac.join("jdk-25.0.1+8"), MAC_ARM).unwrap(), mac.join("jdk-25.0.1+8/Contents/Home"));
+ // Linux tar.gz / Windows zip: jdk-25.0.1+8/bin/java[.exe]
+ for platform in [LINUX_X64, WIN_X64] {
+ let dir = tmp.path().join(format!("{:?}", platform.os));
+ fake_jdk(&dir.join("jdk-25.0.1+8"), platform);
+ let home = find_jdk_home(&dir, platform).unwrap();
+ assert_eq!(home, dir.join("jdk-25.0.1+8"));
+ assert_eq!(unpacked_root(&dir, &home), dir.join("jdk-25.0.1+8"));
+ }
+ // Without a top-level folder, everything unpacked is the JDK.
+ let flat = tmp.path().join("flat");
+ fake_jdk(&flat, LINUX_X64);
+ assert_eq!(find_jdk_home(&flat, LINUX_X64).unwrap(), flat);
+ assert_eq!(unpacked_root(&flat, &flat), flat);
+ let bundle = tmp.path().join("bundle");
+ fake_jdk(&bundle.join("Contents/Home"), MAC_ARM);
+ assert_eq!(unpacked_root(&bundle, &bundle.join("Contents/Home")), bundle);
+ // A Windows layout isn't a JDK for Linux (no `bin/java`), nor is a folder without `release`.
+ assert_eq!(find_jdk_home(&tmp.path().join("Windows"), LINUX_X64), None);
+ std::fs::create_dir_all(tmp.path().join("norelease/bin")).unwrap();
+ std::fs::write(tmp.path().join("norelease/bin/java"), "").unwrap();
+ assert_eq!(find_jdk_home(&tmp.path().join("norelease"), LINUX_X64), None);
+ }
+
+ #[test]
+ fn unknown_vendors_are_refused() {
+ let tools = Tools::with_paths(PathBuf::from("/nonexistent"), Default::default(), LINUX_X64);
+ let err = tools.download_jdk("acme", 25, None, &CancellationToken::new(), &|_| {}).unwrap_err();
+ assert_eq!(err.kind, ErrorKind::InvalidInput, "{err:?}");
+ }
+
+ /// Downloads a real JDK from Adoptium: `OPENIDEA_LIVE_JDK=25 cargo nextest run -p ide-tools live_download`;
+ /// `OPENIDEA_LIVE_JDK_OS=windows|linux` fetches and unpacks another platform's archive (not run).
+ #[test]
+ fn live_download() {
+ let Some(feature) = std::env::var("OPENIDEA_LIVE_JDK").ok().and_then(|v| v.parse::<u32>().ok()) else {
+ return;
+ };
+ let tmp = tempfile::tempdir().unwrap();
+ let other = match std::env::var("OPENIDEA_LIVE_JDK_OS").as_deref() {
+ Ok("windows") => Some(WIN_X64),
+ Ok("linux") => Some(LINUX_X64),
+ _ => None,
+ };
+ if let Some(platform) = other {
+ let tools = Tools::with_paths(crate::tools_dir(tmp.path()), crate::default_search_path(), platform);
+ let jdk = tools.download_jdk(TEMURIN, feature, None, &CancellationToken::new(), &|_| {}).unwrap();
+ let home = jdk.home.into_path_buf();
+ eprintln!("{}", home.display());
+ assert!(home.join("bin").join(platform.exe("java")).is_file());
+ assert_eq!(home.parent(), Some(jdks_dir(tmp.path()).as_path()), "no Contents/Home outside macOS");
+ return;
+ }
+ let tools = Tools::new(tmp.path());
+ let releases = tools.jdk_releases(TEMURIN, &CancellationToken::new()).unwrap();
+ assert!(releases.versions.contains(&feature), "{releases:?}");
+ let emit = |e: InstallEvent| {
+ if let InstallEvent::Line { text } = e {
+ eprintln!("{text}");
+ }
+ };
+ let jdk = tools.download_jdk(TEMURIN, feature, None, &CancellationToken::new(), &emit).unwrap();
+ let home = jdk.home.clone().into_path_buf();
+ assert!(home.starts_with(jdks_dir(tmp.path())), "{}", home.display());
+ let out = std::process::Command::new(home.join("bin").join(Platform::current().exe("java")))
+ .arg("-version")
+ .output()
+ .unwrap();
+ let text = String::from_utf8_lossy(&out.stderr);
+ eprintln!("{text}");
+ assert!(out.status.success() && text.contains("Temurin"), "{text}");
+ // Downloading again reuses it.
+ let again = tools.download_jdk(TEMURIN, feature, None, &CancellationToken::new(), &|_| {}).unwrap();
+ assert_eq!(again.home, jdk.home);
+ }
+}
diff --git a/crates/ide-tools/src/lib.rs b/crates/ide-tools/src/lib.rs
index f11db8bf1..3e00a6cd6 100644
--- a/crates/ide-tools/src/lib.rs
+++ b/crates/ide-tools/src/lib.rs
@@ -10,6 +10,7 @@
//! [`tools_bin_dirs`] on the process `PATH` at startup.
pub mod archive;
+pub mod jdk;
pub mod platform;
mod process;
pub mod registry;
@@ -948,33 +949,7 @@ impl Tools {
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<()> {
- let archive = staging.join(&dl.name);
- http.download(&dl.url, &archive, dl.size, cancel, emit)?;
- let expected = match (&dl.sha256, &dl.checksum_url) {
- (Some(h), _) => Some(h.clone()),
- (None, Some(url)) => match http.get_text(url, cancel) {
- Ok(text) => sources::parse_checksum(&text, &dl.name),
- Err(e) if e.kind == ErrorKind::Cancelled => return Err(e),
- Err(_) => None,
- },
- (None, None) => None,
- };
- match expected {
- Some(expected) => {
- let actual = sources::sha256_file(&archive)?;
- if actual != expected {
- return Err(IdeError::new(
- ErrorKind::Io,
- format!("checksum mismatch for {}: expected {expected}, got {actual}", dl.name),
- ));
- }
- emit(InstallEvent::Line { text: "Checksum verified (SHA-256)".into() });
- }
- None => emit(InstallEvent::Line { text: "No checksum published; skipping verification".into() }),
- }
- if cancel.is_cancelled() {
- return Err(IdeError::cancelled());
- }
+ let archive = fetch_verified(http, dl, staging, cancel, emit)?;
emit(InstallEvent::Line { text: "Extracting…".into() });
let pkg = staging.join("pkg");
let kind = archive::ArchiveKind::from_name(&dl.name);
@@ -1018,11 +993,8 @@ impl Tools {
archive::link_executable(&bin, main, &target)?;
}
}
- #[cfg(target_os = "macos")]
- {
- // Downloads made by the IDE itself are not quarantined, but archives may carry the flag.
- let _ = Command::new("xattr").args(["-dr", "com.apple.quarantine"]).arg(&final_dir).output();
- }
+ // Downloads made by the IDE itself are not quarantined, but archives may carry the flag.
+ clear_quarantine(&final_dir);
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
}
@@ -1091,5 +1063,54 @@ impl Tools {
}
}
+/// Downloads `dl` into `staging` and checks its SHA-256 when one is published;
+/// returns the downloaded file.
+fn fetch_verified(
+ http: &Http,
+ dl: &sources::Download,
+ staging: &Path,
+ cancel: &CancellationToken,
+ emit: Emit,
+) -> IdeResult<PathBuf> {
+ let archive = staging.join(&dl.name);
+ http.download(&dl.url, &archive, dl.size, cancel, emit)?;
+ let expected = match (&dl.sha256, &dl.checksum_url) {
+ (Some(h), _) => Some(h.clone()),
+ (None, Some(url)) => match http.get_text(url, cancel) {
+ Ok(text) => sources::parse_checksum(&text, &dl.name),
+ Err(e) if e.kind == ErrorKind::Cancelled => return Err(e),
+ Err(_) => None,
+ },
+ (None, None) => None,
+ };
+ match expected {
+ Some(expected) => {
+ let actual = sources::sha256_file(&archive)?;
+ if actual != expected {
+ return Err(IdeError::new(
+ ErrorKind::Io,
+ format!("checksum mismatch for {}: expected {expected}, got {actual}", dl.name),
+ ));
+ }
+ emit(InstallEvent::Line { text: "Checksum verified (SHA-256)".into() });
+ }
+ None => emit(InstallEvent::Line { text: "No checksum published; skipping verification".into() }),
+ }
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ Ok(archive)
+}
+
+/// Removes the quarantine flag archives may carry, so macOS runs what was unpacked.
+fn clear_quarantine(dir: &Path) {
+ #[cfg(target_os = "macos")]
+ {
+ let _ = Command::new("xattr").args(["-dr", "com.apple.quarantine"]).arg(dir).output();
+ }
+ #[cfg(not(target_os = "macos"))]
+ let _ = dir;
+}
+
#[cfg(test)]
mod tests;
diff --git a/src-tauri/src/commands/build.rs b/src-tauri/src/commands/build.rs
index 4ec6b4206..05bb1336a 100644
--- a/src-tauri/src/commands/build.rs
+++ b/src-tauri/src/commands/build.rs
@@ -42,6 +42,28 @@ pub(crate) fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel
if let Some(g) = &mut model.gradle {
g.env = java_env(jdk.as_ref(), g.java_version);
}
+ // A failed sync of a project no installed JDK can build says so first (with a Download JDK action).
+ let missing = |release: Option<u32>| match jdk {
+ Some(_) => None,
+ None => ide_sdk::java::missing_jdk_message(&ide_sdk::java::installed_jdks(), release),
+ };
+ let explain = |error: &mut Option<String>, hint: Option<String>| {
+ if let (Some(e), Some(hint)) = (error.as_mut(), hint) {
+ *e = format!("{hint}\n{e}");
+ }
+ };
+ if let Some(m) = &mut model.maven
+ && m.sync_error.is_some()
+ {
+ let hint = m.projects.iter().find_map(|p| missing(p.java_version));
+ explain(&mut m.sync_error, hint);
+ }
+ if let Some(g) = &mut model.gradle
+ && g.sync_error.is_some()
+ {
+ let hint = missing(g.java_version);
+ explain(&mut g.sync_error, hint);
+ }
model
}
diff --git a/src-tauri/src/commands/java.rs b/src-tauri/src/commands/java.rs
index 76a56de12..c75dd7b39 100644
--- a/src-tauri/src/commands/java.rs
+++ b/src-tauri/src/commands/java.rs
@@ -48,6 +48,7 @@ pub async fn java_resolve_launch(
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_jdtls).or_else(|| {
let release = ide_sdk::java::project_java_version(&module);
let jdks = ide_sdk::java::installed_jdks();
+ info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
});
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index c30394997..7dec66ab6 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -253,6 +253,10 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
tools::tools_list,
tools::tools_install,
tools::tools_uninstall,
+ tools::jdk_download_vendors,
+ tools::jdk_download_releases,
+ tools::jdk_download_location,
+ tools::jdk_download,
sdk::sdk_detect,
sdk::sdk_python_effective,
sdk::sdk_project_libraries,
diff --git a/src-tauri/src/commands/tools.rs b/src-tauri/src/commands/tools.rs
index 729f6324e..184f7ec71 100644
--- a/src-tauri/src/commands/tools.rs
+++ b/src-tauri/src/commands/tools.rs
@@ -1,8 +1,11 @@
-//! Language server / debug adapter installer (`ide-tools`).
+//! Language server / debug adapter installer and JDK downloads (`ide-tools`).
use crate::state::AppState;
use ide_core::{IdeError, IdeResult, RequestId};
+use ide_sdk::Sdk;
+use ide_tools::jdk::{JdkReleases, JdkVendor};
use ide_tools::{InstallEvent, ToolInfo, Tools};
+use std::path::PathBuf;
use tauri::ipc::Channel;
use tauri::{AppHandle, Manager, State, Window};
@@ -81,6 +84,81 @@ pub async fn tools_uninstall(
Ok(info)
}
+/// JDK distributions Download JDK offers.
+#[tauri::command]
+#[specta::specta]
+pub fn jdk_download_vendors() -> Vec<JdkVendor> {
+ ide_tools::jdk::vendors()
+}
+
+/// Java versions `vendor` publishes; cancellable with `cancel_request(request)`.
+#[tauri::command]
+#[specta::specta]
+pub async fn jdk_download_releases(
+ app: AppHandle,
+ window: Window,
+ state: State<'_, AppState>,
+ vendor: String,
+ request: RequestId,
+) -> IdeResult<JdkReleases> {
+ let tools = tools(&app, &state, &window)?;
+ let cancel = state.begin_request(request);
+ let result =
+ tauri::async_runtime::spawn_blocking(move || tools.jdk_releases(&vendor, &cancel)).await.map_err(join_err);
+ state.end_request(request);
+ result?
+}
+
+/// Where Download JDK puts JDKs unless told otherwise.
+#[tauri::command]
+#[specta::specta]
+pub fn jdk_download_location(app: AppHandle) -> IdeResult<ide_core::IpcPath> {
+ let data = app.path().app_data_dir().map_err(|e| IdeError::internal(e.to_string()))?;
+ Ok(ide_tools::jdk::jdks_dir(&data).into())
+}
+
+/// Downloads the latest `vendor` JDK of Java `version` into `location` (default:
+/// [`jdk_download_location`]), streaming progress through `on_event`; cancellable
+/// with `cancel_request(request)`. The JDK is then detected like an installed one,
+/// and language servers waiting for a JDK (jdtls) start on it.
+#[tauri::command]
+#[specta::specta]
+#[allow(clippy::too_many_arguments)]
+pub async fn jdk_download(
+ app: AppHandle,
+ window: Window,
+ state: State<'_, AppState>,
+ vendor: String,
+ version: u32,
+ location: Option<PathBuf>,
+ request: RequestId,
+ on_event: Channel<InstallEvent>,
+) -> IdeResult<Sdk> {
+ let tools = tools(&app, &state, &window)?;
+ let location = location.filter(|p| !p.as_os_str().is_empty());
+ let cancel = state.begin_request(request);
+ let result = tauri::async_runtime::spawn_blocking(move || {
+ let jdk = tools.download_jdk(&vendor, version, location.as_deref(), &cancel, &|e| {
+ let _ = on_event.send(e);
+ })?;
+ let home = jdk.home.into_path_buf();
+ // A chosen location is scanned from now on too (the default one is from startup).
+ if let Some(location) = &location {
+ ide_sdk::java::add_jdk_root(location);
+ }
+ ide_sdk::java::rescan_jdks();
+ let jdk = ide_sdk::java::jdk_at(&home)
+ .ok_or_else(|| IdeError::internal(format!("{} is not a JDK home", home.display())))?;
+ IdeResult::Ok(ide_sdk::jdk_sdk(&jdk))
+ })
+ .await
+ .map_err(join_err);
+ state.end_request(request);
+ let sdk = result??;
+ reconfigure_servers(&state);
+ Ok(sdk)
+}
+
fn reconfigure_servers(state: &AppState) {
for project in state.projects() {
let lsp = project.lsp.clone();
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 63441fef4..463721f43 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -41,6 +41,7 @@ pub fn run() {
if let Some(data) = dirs::data_dir() {
ide_tools::extend_process_path(&data.join(&context.config().identifier));
ide_dap::adapter::set_tools_root(ide_tools::tools_dir(&data.join(&context.config().identifier)));
+ ide_sdk::java::add_jdk_root(&ide_tools::jdk::jdks_dir(&data.join(&context.config().identifier)));
}
if let Some(refresh) = refresh_shell_path {
refresh();
diff --git a/src/bindings.ts b/src/bindings.ts
index c76ff5c57..a4eebe9f7 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -497,6 +497,19 @@ export const commands = {
toolsInstall: (name: string, request: RequestId, onEvent: Channel<InstallEvent>) => typedError<ToolInfo, IdeError>(__TAURI_INVOKE("tools_install", { name, request, onEvent })),
/** Removes a tool the IDE installed. */
toolsUninstall: (name: string) => typedError<ToolInfo, IdeError>(__TAURI_INVOKE("tools_uninstall", { name })),
+ /** JDK distributions Download JDK offers. */
+ jdkDownloadVendors: () => __TAURI_INVOKE<JdkVendor[]>("jdk_download_vendors"),
+ /** Java versions `vendor` publishes; cancellable with `cancel_request(request)`. */
+ jdkDownloadReleases: (vendor: string, request: RequestId) => typedError<JdkReleases, IdeError>(__TAURI_INVOKE("jdk_download_releases", { vendor, request })),
+ /** Where Download JDK puts JDKs unless told otherwise. */
+ jdkDownloadLocation: () => typedError<IpcPath, IdeError>(__TAURI_INVOKE("jdk_download_location")),
+ /**
+ * Downloads the latest `vendor` JDK of Java `version` into `location` (default:
+ * [`jdk_download_location`]), streaming progress through `on_event`; cancellable
+ * with `cancel_request(request)`. The JDK is then detected like an installed one,
+ * and language servers waiting for a JDK (jdtls) start on it.
+ */
+ jdkDownload: (vendor: string, version: number, location: string | null, request: RequestId, onEvent: Channel<InstallEvent>) => typedError<Sdk, IdeError>(__TAURI_INVOKE("jdk_download", { vendor, version, location, request, onEvent })),
/** Installed interpreters / toolchains of `kind`; project-local ones first. */
sdkDetect: (kind: SdkKind) => typedError<Sdk[], IdeError>(__TAURI_INVOKE("sdk_detect", { kind })),
/** The interpreter the project uses: the configured one, else its virtualenv. */
@@ -2888,6 +2901,22 @@ export type JavaSettings = {
maven?: MavenSettings,
};
+/** Java versions a vendor publishes. */
+export type JdkReleases = {
+ /** Feature versions, newest first. */
+ versions: number[],
+ /** The long-term-support ones among them. */
+ lts: number[],
+ /** The version offered first (the newest LTS). */
+ recommended: number,
+};
+
+/** A JDK distribution the IDE can download. */
+export type JdkVendor = {
+ id: string,
+ name: string,
+};
+
/** Editor › Code Style › <Language> › Tabs and Indents (unset fields inherit). */
export type LanguageCodeStyle = LanguageCodeStyle_Serialize | LanguageCodeStyle_Deserialize;
diff --git a/src/features/build-tools/BuildToolView.tsx b/src/features/build-tools/BuildToolView.tsx
index 7026d69f8..f4b64d6d4 100644
--- a/src/features/build-tools/BuildToolView.tsx
+++ b/src/features/build-tools/BuildToolView.tsx
@@ -2,6 +2,7 @@
import { useCallback, useEffect, useMemo, useState, type MouseEvent } from "react";
import clsx from "clsx";
import type { BuildTool, GradleModel, MavenModel, RunConfig } from "@/platform/ipc";
+import { downloadJdkActions } from "@/platform/jdk";
import { useProject } from "@/platform/project";
import { editorService } from "@/workbench/contributions";
import {
@@ -191,13 +192,20 @@ function Banner({ tool }: { tool: BuildTool }) {
</Button>
</div>
);
- if (info.syncError)
+ if (info.syncError) {
+ const [jdkFix] = downloadJdkActions(info.syncError);
return (
<div className={clsx(styles.banner, styles.bannerWarning)} title={info.syncError}>
<Icon name="warning" size={16} />
<span className={styles.bannerText}>{info.syncError.split("\n")[0]}</span>
+ {jdkFix && (
+ <Button size="small" variant="ghost" onClick={jdkFix.run}>
+ {jdkFix.label}
+ </Button>
+ )}
</div>
);
+ }
return null;
}
diff --git a/src/features/build-tools/store.ts b/src/features/build-tools/store.ts
index 4125f0921..1d12067bd 100644
--- a/src/features/build-tools/store.ts
+++ b/src/features/build-tools/store.ts
@@ -20,6 +20,7 @@ import {
type RunConfig,
type SyncProgress,
} from "@/platform/ipc";
+import { downloadJdkActions } from "@/platform/jdk";
import { useProject } from "@/platform/project";
import { notifications } from "@/workbench/contributions";
import { removeTask, upsertTask } from "@/workbench/tasks";
@@ -207,6 +208,7 @@ export async function syncTool(tool: BuildTool): Promise<void> {
title: tool === "maven" ? "Maven sync finished with errors" : "Gradle sync failed",
body: error,
key: `build-sync-${tool}`,
+ actions: downloadJdkActions(error),
});
} catch (e) {
if (!isCancelled(e))
diff --git a/src/features/code-insight/ServerStatus.test.tsx b/src/features/code-insight/ServerStatus.test.tsx
new file mode 100644
index 000000000..fbb023603
--- /dev/null
+++ b/src/features/code-insight/ServerStatus.test.tsx
@@ -0,0 +1,34 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { registerAction } from "@/platform/actions";
+import { ServerStatus } from "./ServerStatus";
+import { useServers, type ServerEntry } from "./servers";
+
+const ISSUE_49 =
+ "jdtls needs JDK 25 or newer to run (found JDK 8, 17, 21). Download JDK 25, or pick an installed one in Settings › Languages & Frameworks › Java › Language Server › JDK (it restarts automatically); the project can still target an older Java version.";
+
+const server = (status: ServerEntry["status"], message: string | null): ServerEntry =>
+ ({ id: 1, name: "jdtls", status, message, languages: ["Java"], root: null }) as unknown as ServerEntry;
+
+afterEach(() => useServers.setState({ servers: new Map() }));
+
+describe("Language server status popup", () => {
+ it("offers Download JDK N when jdtls can't start for want of a JDK", () => {
+ const run = vi.fn();
+ const off = registerAction({ id: "java.downloadJdk", title: "Download JDK…", run: ({ arg }) => run(arg) });
+ useServers.setState({ servers: new Map([[1 as never, server("misconfigured", ISSUE_49)]]) });
+ render(<ServerStatus />);
+ fireEvent.click(screen.getByRole("button", { name: /Language servers/ }));
+ fireEvent.click(screen.getByRole("button", { name: "Download JDK 25" }));
+ expect(run).toHaveBeenCalledWith({ version: 25, languageServer: true });
+ off();
+ });
+
+ it("keeps Restart for other failures", () => {
+ useServers.setState({ servers: new Map([[1 as never, server("crashed", "exit code 1")]]) });
+ render(<ServerStatus />);
+ fireEvent.click(screen.getByRole("button", { name: /Language servers/ }));
+ expect(screen.queryByRole("button", { name: /Download JDK/ })).toBeNull();
+ expect(screen.getByRole("button", { name: "Restart jdtls" })).toBeInTheDocument();
+ });
+});
diff --git a/src/features/code-insight/ServerStatus.tsx b/src/features/code-insight/ServerStatus.tsx
index 4c521518f..07115acbc 100644
--- a/src/features/code-insight/ServerStatus.tsx
+++ b/src/features/code-insight/ServerStatus.tsx
@@ -3,6 +3,7 @@ import { useMemo, useRef, useState } from "react";
import clsx from "clsx";
import { getAction, executeAction } from "@/platform/actions";
import { BarButton, Button, IconButton, Popup, T } from "@/ui";
+import { downloadJdkActions } from "@/platform/jdk";
import { relativePath, useProject } from "@/platform/project";
import { STATUS_LABEL, restartServer, serversSummary, useServers } from "./servers";
import styles from "./ServerStatus.module.css";
@@ -41,45 +42,59 @@ export function ServerStatus() {
<div className={styles.header}>
<T>Language Servers</T>
</div>
- {servers.map((s) => (
- <div key={s.id} className={styles.server}>
- <div className={styles.line}>
- <span className={clsx(styles.dot, styles[toneOf(s.status)])} aria-hidden />
- <span className={styles.name}>{s.name}</span>
- <span className={styles.status}>{STATUS_LABEL[s.status]}</span>
- <span className={styles.spacer} />
- {s.status === "missing" && canInstall ? (
- <Button
- size="small"
- aria-label={`Install ${s.name}`}
- onClick={() => {
- setOpen(false);
- void executeAction("tools.install", s.name);
- }}
- >
- <T>Install</T>
- </Button>
- ) : (
- <IconButton
- icon="refresh"
- size="small"
- title={`Restart ${s.name}`}
- disabled={s.status === "missing" || s.status === "starting"}
- onClick={() => void restartServer(s.id)}
- />
+ {servers.map((s) => {
+ // jdtls without a JDK new enough to run it: "Download JDK 25".
+ const [jdkFix] = s.status === "misconfigured" ? downloadJdkActions(s.message) : [];
+ return (
+ <div key={s.id} className={styles.server}>
+ <div className={styles.line}>
+ <span className={clsx(styles.dot, styles[toneOf(s.status)])} aria-hidden />
+ <span className={styles.name}>{s.name}</span>
+ <span className={styles.status}>{STATUS_LABEL[s.status]}</span>
+ <span className={styles.spacer} />
+ {jdkFix ? (
+ <Button
+ size="small"
+ onClick={() => {
+ setOpen(false);
+ jdkFix.run();
+ }}
+ >
+ {jdkFix.label}
+ </Button>
+ ) : s.status === "missing" && canInstall ? (
+ <Button
+ size="small"
+ aria-label={`Install ${s.name}`}
+ onClick={() => {
+ setOpen(false);
+ void executeAction("tools.install", s.name);
+ }}
+ >
+ <T>Install</T>
+ </Button>
+ ) : (
+ <IconButton
+ icon="refresh"
+ size="small"
+ title={`Restart ${s.name}`}
+ disabled={s.status === "missing" || s.status === "starting"}
+ onClick={() => void restartServer(s.id)}
+ />
+ )}
+ </div>
+ {(s.languages.length > 0 || s.root) && (
+ <div className={styles.meta}>
+ {s.languages.join(", ")}
+ {s.root && s.root !== root ? ` · ${relativePath(root, s.root) || s.root}` : ""}
+ </div>
+ )}
+ {s.message && (
+ <div className={clsx(styles.message, s.status === "missing" && styles.install)}>{s.message}</div>
)}
</div>
- {(s.languages.length > 0 || s.root) && (
- <div className={styles.meta}>
- {s.languages.join(", ")}
- {s.root && s.root !== root ? ` · ${relativePath(root, s.root) || s.root}` : ""}
- </div>
- )}
- {s.message && (
- <div className={clsx(styles.message, s.status === "missing" && styles.install)}>{s.message}</div>
- )}
- </div>
- ))}
+ );
+ })}
</div>
</Popup>
</>
diff --git a/src/features/debugger/actions.ts b/src/features/debugger/actions.ts
index 761f2da99..9510f9875 100644
--- a/src/features/debugger/actions.ts
+++ b/src/features/debugger/actions.ts
@@ -1,6 +1,7 @@
/** Debugger actions (ids match `keymaps/intellij-macos.ts`). */
import { registerActions, type Action } from "@/platform/actions";
import { call, commands, isCancelled, isTauri, nextRequestId, type RunConfig, type RunId } from "@/platform/ipc";
+import { downloadJdkActions } from "@/platform/jdk";
import { useProject } from "@/platform/project";
import { activeEditor } from "@/editor/api";
import { maybeEditorService, notifications, toolWindowService } from "@/workbench/contributions";
@@ -55,7 +56,9 @@ async function report(title: string, p: Promise<unknown>) {
try {
await p;
} catch (e) {
- notifications().notify({ group: "run", level: "error", title, body: errorText(e), key: "debug.action" });
+ // A Java launch without a JDK new enough (for jdtls or the project) offers to download one.
+ const actions = downloadJdkActions(errorText(e));
+ notifications().notify({ group: "run", level: "error", title, body: errorText(e), key: "debug.action", actions });
}
}
diff --git a/src/features/run/producers.ts b/src/features/run/producers.ts
index 42e2d304c..a64bec9d4 100644
--- a/src/features/run/producers.ts
+++ b/src/features/run/producers.ts
@@ -269,7 +269,7 @@ const INSTALL: Record<string, string> = {
r: "Install R (`brew install r`) so that `Rscript` is on the PATH.",
go: "Install Go from https://go.dev/dl (or `brew install go`).",
rust: "Install Rust with rustup: https://rustup.rs",
- java: "Install a JDK 11+ (`brew install openjdk`) so that `java` is on the PATH.",
+ java: "Install a JDK 11+ (`brew install openjdk`), or download one in Settings › Languages & Frameworks › Java (Project JDK › Download JDK…).",
kotlin: "Install the Kotlin compiler (`brew install kotlin`, or https://kotlinlang.org/docs/command-line.html) so that `kotlinc` is on the PATH.",
"kotlin-script": "Install Kotlin (`brew install kotlin`).",
swift: "Install the Xcode command line tools (`xcode-select --install`).",
diff --git a/src/features/run/store.ts b/src/features/run/store.ts
index 7f1d15f6f..05270508f 100644
--- a/src/features/run/store.ts
+++ b/src/features/run/store.ts
@@ -7,6 +7,7 @@ import { create } from "zustand";
import { Channel } from "@tauri-apps/api/core";
import { call, commands, isTauri, type OutputChunk, type RunConfig, type RunId, type TestCaseReport } from "@/platform/ipc";
import { formatCompileErrors, isJvmApplication, parseJavaArgs, resolveJavaCommand } from "@/platform/javaLaunch";
+import { downloadJdkActions } from "@/platform/jdk";
import { useProject } from "@/platform/project";
import { executeAction } from "@/platform/actions";
import { workflowSettings } from "@/platform/workflowSettings";
@@ -590,6 +591,17 @@ async function resolveJvmApplication(sessionId: string, config: RunConfig): Prom
if (info.build === "failed") say("Build failed; launching with the last compiled classes.\n", "stderr");
const compileReport = formatCompileErrors(info);
if (compileReport) say(compileReport, "stderr");
+ // No installed JDK is new enough for the module: offer to download one.
+ const jdkHint = info.hints.find((h) => downloadJdkActions(h).length);
+ if (jdkHint)
+ notifications().notify({
+ group: "run",
+ level: "warning",
+ key: "run.jdk-missing",
+ title: `No JDK can run '${config.name}'`,
+ body: jdkHint,
+ actions: downloadJdkActions(jdkHint),
+ });
if (!info.classPaths.length) {
say("The classpath is empty: is the module imported by the Java language server?\n", "stderr");
return null;
@@ -598,7 +610,9 @@ async function resolveJvmApplication(sessionId: string, config: RunConfig): Prom
} catch (e) {
const message = e instanceof Error ? e.message : String(e);
say(`Cannot resolve the classpath: ${message}\n`, "stderr");
- notifications().notify({ group: "run", level: "error", title: `Cannot run '${config.name}'`, body: message });
+ // jdtls can't start without a newer JDK: "Download JDK 25".
+ const actions = downloadJdkActions(message);
+ notifications().notify({ group: "run", level: "error", title: `Cannot run '${config.name}'`, body: message, actions });
return null;
}
}
diff --git a/src/features/settings/__tests__/downloadJdk.test.tsx b/src/features/settings/__tests__/downloadJdk.test.tsx
new file mode 100644
index 000000000..f6e650d03
--- /dev/null
+++ b/src/features/settings/__tests__/downloadJdk.test.tsx
@@ -0,0 +1,71 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import type { InstallEvent, Sdk } from "@/platform/ipc";
+
+const ok = <T,>(data: T) => ({ status: "ok" as const, data });
+vi.mock("@/platform/ipc", async (importOriginal) => {
+ const real = await importOriginal<typeof import("@/platform/ipc")>();
+ return {
+ ...real,
+ isTauri: () => true,
+ commands: {
+ ...real.commands,
+ jdkDownloadVendors: async () => [{ id: "temurin", name: "Eclipse Temurin" }],
+ jdkDownloadReleases: async () =>
+ ok({ versions: [26, 25, 21, 17, 11, 8], lts: [8, 11, 17, 21, 25], recommended: 25 }),
+ jdkDownloadLocation: async () => ok("/data/tools/jdks"),
+ cancelRequest: async () => ok(null),
+ },
+ };
+});
+
+const SDK: Sdk = {
+ path: "/data/tools/jdks/temurin-25.0.1",
+ name: "Eclipse Adoptium 25.0.1",
+ version: "25.0.1",
+ source: "downloaded",
+ home: "/data/tools/jdks/temurin-25.0.1",
+ extra: null,
+};
+let finish: (sdk: Sdk) => void = () => {};
+const cancel = vi.fn();
+const downloadJdk = vi.fn((_v: string, _n: number, _l: string | null, onEvent: (e: InstallEvent) => void) => {
+ onEvent({ type: "progress", fraction: 0.25, message: "Downloaded 50.0 of 200.0 MB" });
+ return { promise: new Promise<Sdk>((r) => (finish = r)), cancel };
+});
+vi.mock("@/platform/jdk", async (orig) => ({ ...(await orig<typeof import("@/platform/jdk")>()), downloadJdk }));
+
+const { DownloadJdkDialog } = await import("../languages/DownloadJdkDialog");
+const { useSdks } = await import("../languages/api");
+
+afterEach(() => vi.clearAllMocks());
+
+describe("Download JDK dialog", () => {
+ it("downloads the newest LTS into the IDE's JDK folder, with progress, and selects it", async () => {
+ const onDownloaded = vi.fn();
+ const onClose = vi.fn();
+ render(<DownloadJdkDialog onClose={onClose} onDownloaded={onDownloaded} />);
+ await waitFor(() => expect(screen.getByRole("button", { name: "Version" })).toHaveTextContent("25"));
+ expect(screen.getByRole("button", { name: "Vendor" })).toHaveTextContent("Eclipse Temurin");
+ await waitFor(() => expect(screen.getByLabelText("Location:")).toHaveValue("/data/tools/jdks"));
+
+ fireEvent.click(screen.getByRole("button", { name: "Download" }));
+ expect(downloadJdk).toHaveBeenCalledWith("temurin", 25, "/data/tools/jdks", expect.any(Function));
+ expect(screen.getByRole("progressbar", { name: "Downloading JDK" })).toHaveAttribute("aria-valuenow", "25");
+ expect(screen.getByRole("button", { name: "Download" })).toBeDisabled();
+
+ // Closing while downloading cancels the download.
+ fireEvent.keyDown(document.activeElement ?? document.body, { key: "Escape" });
+ expect(cancel).toHaveBeenCalled();
+
+ await act(async () => finish(SDK));
+ expect(onDownloaded).toHaveBeenCalledWith(SDK);
+ expect(useSdks.getState().byKind.jdk?.[0]).toEqual(SDK);
+ });
+
+ it("preselects the version a fix asks for", async () => {
+ render(<DownloadJdkDialog initialVersion={21} onClose={() => {}} onDownloaded={() => {}} />);
+ await waitFor(() => expect(screen.getByRole("button", { name: "Download" })).toBeEnabled());
+ expect(screen.getByRole("button", { name: "Version" })).toHaveTextContent("21");
+ });
+});
diff --git a/src/features/settings/languages/DownloadJdkDialog.tsx b/src/features/settings/languages/DownloadJdkDialog.tsx
new file mode 100644
index 000000000..c01628a72
--- /dev/null
+++ b/src/features/settings/languages/DownloadJdkDialog.tsx
@@ -0,0 +1,168 @@
+/**
+ * IDEA's Download JDK dialog: vendor, Java version and location; downloads the
+ * latest build (SHA-256 verified) with progress and Cancel, then selects it.
+ */
+import { useEffect, useId, useMemo, useState } from "react";
+import { call, commands, isCancelled, isTauri, nextRequestId, type JdkReleases, type Sdk } from "@/platform/ipc";
+import { downloadJdk, TEMURIN, type JdkDownload } from "@/platform/jdk";
+import { Dialog, IconButton, Input, ProgressBar, Select, type SelectOption, T } from "@/ui";
+import { choosePath, rememberSdk } from "./api";
+import styles from "./Sdk.module.css";
+
+const errorText = (e: unknown) => (e instanceof Error ? e.message : String(e));
+
+export function DownloadJdkDialog({
+ initialVersion,
+ onClose,
+ onDownloaded,
+}: {
+ /** Preselected Java version (e.g. the one jdtls needs); default: the newest LTS. */
+ initialVersion?: number;
+ onClose: () => void;
+ onDownloaded: (sdk: Sdk) => void;
+}) {
+ const [vendors, setVendors] = useState<SelectOption[]>([{ value: TEMURIN, label: "Eclipse Temurin" }]);
+ const [vendor, setVendor] = useState(TEMURIN);
+ const [releases, setReleases] = useState<JdkReleases | null>(null);
+ const [version, setVersion] = useState<string | null>(initialVersion ? String(initialVersion) : null);
+ const [location, setLocation] = useState("");
+ const [job, setJob] = useState<JdkDownload | null>(null);
+ const [progress, setProgress] = useState<{ fraction: number | null; message: string } | null>(null);
+ const [error, setError] = useState<string | null>(null);
+ const locationId = useId();
+
+ useEffect(() => {
+ if (!isTauri()) return;
+ commands
+ .jdkDownloadVendors()
+ .then((list) => setVendors(list.map((v) => ({ value: v.id, label: v.name }))))
+ .catch(() => {});
+ void call(commands.jdkDownloadLocation())
+ .then((dir) => setLocation((cur) => cur || dir))
+ .catch(() => {});
+ }, []);
+
+ useEffect(() => {
+ if (!isTauri()) return;
+ const request = nextRequestId();
+ let live = true;
+ call(commands.jdkDownloadReleases(vendor, request))
+ .then((r) => {
+ if (!live) return;
+ setReleases(r);
+ setVersion((v) => (v && r.versions.includes(Number(v)) ? v : String(r.recommended)));
+ })
+ .catch((e: unknown) => live && !isCancelled(e) && setError(`Cannot list the Java versions: ${errorText(e)}`));
+ return () => {
+ live = false;
+ void commands.cancelRequest(request).catch(() => {});
+ };
+ }, [vendor]);
+
+ const versionOptions = useMemo<SelectOption[]>(
+ () =>
+ (releases?.versions ?? []).map((v) => ({
+ value: String(v),
+ label: String(v),
+ detail: releases?.lts.includes(v) ? "LTS" : undefined,
+ })),
+ [releases],
+ );
+
+ const download = () => {
+ if (!version) return;
+ setError(null);
+ setProgress({ fraction: null, message: "Resolving the latest build…" });
+ const next = downloadJdk(vendor, Number(version), location.trim() || null, (e) =>
+ setProgress((p) =>
+ e.type === "progress"
+ ? { fraction: e.fraction, message: e.message }
+ : { fraction: p?.fraction ?? null, message: e.text },
+ ),
+ );
+ setJob(next);
+ next.promise
+ .then((sdk) => {
+ rememberSdk("jdk", sdk);
+ onDownloaded(sdk);
+ })
+ .catch((e: unknown) => {
+ if (!isCancelled(e)) setError(errorText(e));
+ setProgress(null);
+ })
+ .finally(() => setJob(null));
+ };
+
+ const vendorName = vendors.find((v) => v.value === vendor)?.label ?? vendor;
+ return (
+ <Dialog
+ open
+ onClose={() => (job ? job.cancel() : onClose())}
+ title="Download JDK"
+ width={520}
+ aria-label="Download JDK"
+ buttons={[
+ { label: "Download", role: "default", disabled: !version || !!job, onClick: download },
+ { label: "Cancel", role: "cancel" },
+ ]}
+ >
+ <div className={styles.form}>
+ <div className={styles.downloadGrid}>
+ <span>
+ <T>Vendor:</T>
+ </span>
+ <Select value={vendor} options={vendors} onChange={setVendor} disabled={!!job} aria-label="Vendor" />
+ <span>
+ <T>Version:</T>
+ </span>
+ <Select
+ value={version}
+ options={versionOptions}
+ onChange={setVersion}
+ disabled={!!job}
+ placeholder={releases ? "Select a version" : "Loading…"}
+ aria-label="Version"
+ />
+ <label htmlFor={locationId}>
+ <T>Location:</T>
+ </label>
+ <div className={styles.pathRow}>
+ <Input
+ id={locationId}
+ mono
+ className={styles.pathInput}
+ value={location}
+ disabled={!!job}
+ onChange={(e) => setLocation(e.target.value)}
+ />
+ <IconButton
+ icon="folder-open"
+ size="small"
+ title="Browse…"
+ disabled={!!job}
+ onClick={async () => {
+ const p = await choosePath({ directory: true, title: "JDK Location", defaultPath: location });
+ if (p) setLocation(p);
+ }}
+ />
+ </div>
+ </div>
+ <div className={styles.note}>
+ {vendorName} {version ?? ""} is unpacked into a folder of its own in {location || "…"}, where JDK detection
+ finds it.
+ </div>
+ {progress && (
+ <div className={styles.downloadProgress}>
+ <ProgressBar value={progress.fraction} aria-label="Downloading JDK" />
+ <span className={styles.note}>{progress.message}</span>
+ </div>
+ )}
+ {error && (
+ <div className={styles.error} role="alert">
+ {error}
+ </div>
+ )}
+ </div>
+ </Dialog>
+ );
+}
diff --git a/src/features/settings/languages/LanguagePages.tsx b/src/features/settings/languages/LanguagePages.tsx
index efe571a65..eca7dfe98 100644
--- a/src/features/settings/languages/LanguagePages.tsx
+++ b/src/features/settings/languages/LanguagePages.tsx
@@ -244,7 +244,7 @@ export function JavaPage() {
directory
browseTitle="Select JDK Home Directory"
aria-label="Language server JDK"
- hint="Runs jdtls only, like IDEA's JDK for importer; the project keeps compiling and running with the Project JDK. jdtls needs JDK 21 or newer (recent releases 25). The jdtls executable itself is set in Language Servers."
+ hint="Runs jdtls only, like IDEA's JDK for importer; the project keeps compiling and running with the Project JDK. jdtls needs JDK 21 or newer (recent releases 25); Download JDK… in the list fetches one. The jdtls executable itself is set in Language Servers."
/>
<Row
label="JVM options"
diff --git a/src/features/settings/languages/Sdk.module.css b/src/features/settings/languages/Sdk.module.css
index aa43406aa..a21b2d574 100644
--- a/src/features/settings/languages/Sdk.module.css
+++ b/src/features/settings/languages/Sdk.module.css
@@ -357,3 +357,16 @@
color: var(--fg-subtle);
font-size: var(--fs-small);
}
+
+/* Download JDK dialog */
+.downloadGrid {
+ display: grid;
+ grid-template-columns: max-content minmax(0, 1fr);
+ align-items: center;
+ gap: 6px 10px;
+}
+.downloadProgress {
+ display: flex;
+ flex-direction: column;
+ gap: 4px;
+}
diff --git a/src/features/settings/languages/components.tsx b/src/features/settings/languages/components.tsx
index 1b3ffc999..8d537501f 100644
--- a/src/features/settings/languages/components.tsx
+++ b/src/features/settings/languages/components.tsx
@@ -1,9 +1,10 @@
/** Shared controls of the interpreter / toolchain settings pages. */
-import { useEffect, useMemo } from "react";
+import { useEffect, useMemo, useState } from "react";
import { IconButton, Select, Spinner, type SelectOption } from "@/ui";
import { useProject } from "@/platform/project";
import { useSetting } from "../components/context";
import { choosePath, detectSdks, useSdks, type Sdk, type SdkKind } from "./api";
+import { DownloadJdkDialog } from "./DownloadJdkDialog";
import styles from "./Sdk.module.css";
/**
@@ -48,7 +49,10 @@ export interface SdkFieldProps {
extra?: SelectOption[];
}
-/** IDEA's SDK combo: detected installations, the current custom path, and a browse button. */
+/** The "Download JDK…" entry of JDK combos (not a value). */
+const DOWNLOAD_JDK = "\u0000download-jdk";
+
+/** IDEA's SDK combo: detected installations, the current custom path, and a browse button; JDK combos also offer Download JDK…. */
export function SdkField({
kind,
value,
@@ -67,8 +71,10 @@ export function SdkField({
out.push(...(extra ?? []));
for (const sdk of list) out.push({ value: sdk.path, label: sdk.name, detail: tildify(sdk.path) });
if (value && !out.some((o) => o.value === value)) out.push({ value, label: tildify(value), detail: "custom" });
+ if (kind === "jdk") out.push({ value: DOWNLOAD_JDK, label: "Download JDK…", icon: "plus" });
return out;
- }, [list, value, emptyLabel, emptyDetail, extra]);
+ }, [list, value, emptyLabel, emptyDetail, extra, kind]);
+ const [downloading, setDownloading] = useState(false);
const browse = async () => {
const picked = await choosePath({ directory: !!directory, title: browseTitle, defaultPath: value || undefined });
if (picked) onChange(picked);
@@ -79,7 +85,7 @@ export function SdkField({
className={styles.sdkSelect}
value={value}
options={options}
- onChange={onChange}
+ onChange={(v) => (v === DOWNLOAD_JDK ? setDownloading(true) : onChange(v))}
aria-label={aria["aria-label"]}
placeholder={loading ? "Detecting…" : "<No interpreter>"}
/>
@@ -89,6 +95,15 @@ export function SdkField({
<IconButton icon="refresh" size="small" title="Detect again" onClick={refresh} />
)}
<IconButton icon="folder-open" size="small" title="Browse…" onClick={() => void browse()} />
+ {downloading && (
+ <DownloadJdkDialog
+ onClose={() => setDownloading(false)}
+ onDownloaded={(sdk) => {
+ setDownloading(false);
+ onChange(sdk.path);
+ }}
+ />
+ )}
</span>
);
}
diff --git a/src/features/tools/__tests__/jdk.test.ts b/src/features/tools/__tests__/jdk.test.ts
new file mode 100644
index 000000000..f84952a14
--- /dev/null
+++ b/src/features/tools/__tests__/jdk.test.ts
@@ -0,0 +1,116 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { InstallEvent, Sdk, Settings } from "@/bindings";
+import type { NotificationService } from "@/workbench/contributions";
+
+const settingsSet = vi.fn(async (_scope: string, _key: string, value: string) => ({
+ status: "ok" as const,
+ data: { languages: { java: { jdtlsJdk: JSON.parse(value) } } } as unknown as Settings,
+}));
+vi.mock("@/platform/ipc", async (orig) => {
+ const actual = await orig<typeof import("@/platform/ipc")>();
+ return { ...actual, commands: { ...actual.commands, settingsSet } };
+});
+
+const SDK: Sdk = {
+ path: "/data/tools/jdks/temurin-25.0.1/Contents/Home",
+ name: "Eclipse Adoptium 25.0.1",
+ version: "25.0.1",
+ source: "downloaded",
+ home: "/data/tools/jdks/temurin-25.0.1/Contents/Home",
+ extra: null,
+};
+let outcome: () => Promise<Sdk>;
+const cancel = vi.fn();
+const downloadJdk = vi.fn(
+ (_vendor: string, _version: number, _location: string | null, onEvent: (e: InstallEvent) => void) => {
+ onEvent({ type: "progress", fraction: 0.5, message: "Downloaded 100.0 of 200.0 MB" });
+ return { promise: outcome(), cancel };
+ },
+);
+vi.mock("@/platform/jdk", async (orig) => ({ ...(await orig<typeof import("@/platform/jdk")>()), downloadJdk }));
+
+const { downloadJdkFor } = await import("../jdk");
+const { useProject } = await import("@/platform/project");
+const { IpcError } = await import("@/platform/ipc");
+const { provideNotificationService } = await import("@/workbench/contributions");
+const { useTasks } = await import("@/workbench/tasks");
+
+type Note = Parameters<NotificationService["notify"]>[0];
+let notes: Note[];
+
+const withServerJdk = (jdtlsJdk: string, project = true) =>
+ useProject.setState({
+ project: project ? ({ root: "/p" } as never) : null,
+ settings: { languages: { java: { jdk: "", jdtlsJdk } } } as never,
+ });
+
+beforeEach(() => {
+ notes = [];
+ provideNotificationService({ notify: (n) => void notes.push(n) });
+ outcome = async () => SDK;
+});
+
+afterEach(() => {
+ useProject.setState({ project: null, settings: null });
+ vi.clearAllMocks();
+});
+
+describe("Download JDK N (one click)", () => {
+ it("downloads Temurin N into the IDE's JDK folder, with progress in the background tasks", async () => {
+ withServerJdk("");
+ const seen: Array<number | null> = [];
+ const unsub = useTasks.subscribe((s) => {
+ const t = s.tasks.find((x) => x.id === "jdk-download:25");
+ if (t && !t.done) seen.push(t.fraction);
+ });
+ const sdk = await downloadJdkFor({ version: 25, languageServer: true });
+ unsub();
+ expect(sdk).toEqual(SDK);
+ expect(downloadJdk).toHaveBeenCalledWith("temurin", 25, null, expect.any(Function));
+ expect(seen).toContain(0.5);
+ // Auto: the backend's rescan makes jdtls pick the new JDK by itself.
+ expect(settingsSet).not.toHaveBeenCalled();
+ expect(notes.at(-1)).toMatchObject({ level: "info", title: "Eclipse Adoptium 25.0.1 downloaded" });
+ });
+
+ it("replaces a language server JDK that is too old (in the project, whose value wins)", async () => {
+ withServerJdk("C:\\Java\\jdk-21");
+ await downloadJdkFor({ version: 25, languageServer: true });
+ expect(settingsSet).toHaveBeenCalledWith("project", "languages.java.jdtlsJdk", JSON.stringify(SDK.path));
+ expect(useProject.getState().settings?.languages?.java?.jdtlsJdk).toBe(SDK.path);
+
+ withServerJdk("/old", false);
+ await downloadJdkFor({ version: 25, languageServer: true });
+ expect(settingsSet).toHaveBeenLastCalledWith("global", "languages.java.jdtlsJdk", JSON.stringify(SDK.path));
+ });
+
+ it("leaves the settings alone for a project JDK (Auto picks it per module)", async () => {
+ withServerJdk("/old");
+ await downloadJdkFor({ version: 21 });
+ expect(settingsSet).not.toHaveBeenCalled();
+ });
+
+ it("deduplicates concurrent downloads of one version", async () => {
+ withServerJdk("");
+ const a = downloadJdkFor({ version: 25 });
+ const b = downloadJdkFor({ version: 25 });
+ expect(a).toBe(b);
+ await a;
+ expect(downloadJdk).toHaveBeenCalledTimes(1);
+ });
+
+ it("reports failures but not cancellation", async () => {
+ withServerJdk("");
+ outcome = async () => {
+ throw new IpcError({ kind: "unavailable", message: "Eclipse Temurin 8 has no build for Linux Arm64" });
+ };
+ expect(await downloadJdkFor({ version: 8 })).toBeNull();
+ expect(notes.at(-1)).toMatchObject({ level: "error", title: "Failed to download JDK 8" });
+ notes = [];
+ outcome = async () => {
+ throw new IpcError({ kind: "cancelled", message: "cancelled" });
+ };
+ expect(await downloadJdkFor({ version: 8 })).toBeNull();
+ expect(notes).toEqual([]);
+ });
+});
diff --git a/src/features/tools/index.ts b/src/features/tools/index.ts
index 075736a2f..37993487d 100644
--- a/src/features/tools/index.ts
+++ b/src/features/tools/index.ts
@@ -2,11 +2,13 @@
* Tools installer: Settings › Languages & Frameworks › Language Servers, plus
* install prompts for missing language servers.
*
- * Actions: `tools.languageServers` (open the page), `tools.install` (arg: tool name).
+ * Actions: `tools.languageServers` (open the page), `tools.install` (arg: tool name),
+ * `java.downloadJdk` (arg: `DownloadJdkArgs`).
*/
import { lazyComponent } from "@/ui";
import { executeAction, registerActions } from "@/platform/actions";
import { registerSettingsPage } from "@/workbench/contributions";
+import { installJdkPrompts, registerJdkActions } from "./jdk";
import { installMissingServerPrompts } from "./missing";
import { installTool, refreshTools, SETTINGS_PAGE_ID, toolByName, useTools } from "./store";
@@ -55,6 +57,8 @@ export function activate(): () => void {
},
]),
installMissingServerPrompts(),
+ registerJdkActions(),
+ installJdkPrompts(),
];
return () => disposers.reverse().forEach((d) => d());
}
diff --git a/src/features/tools/jdk.ts b/src/features/tools/jdk.ts
new file mode 100644
index 000000000..f0479d89c
--- /dev/null
+++ b/src/features/tools/jdk.ts
@@ -0,0 +1,122 @@
+/**
+ * `java.downloadJdk` (arg: `DownloadJdkArgs`): the one-click fix offered where
+ * jdtls, a run configuration or a Maven / Gradle sync lacks a new enough JDK.
+ * Downloads Eclipse Temurin N into the IDE's JDK folder (found by JDK detection
+ * from then on), makes it the language server JDK when a too-old one is chosen
+ * there, and lets the backend restart jdtls on it. Progress and Cancel live in
+ * the status bar's background tasks.
+ */
+import type { Sdk } from "@/bindings";
+import { executeAction, registerActions } from "@/platform/actions";
+import { call, commands, isCancelled, isTauri, onIdeEvent } from "@/platform/ipc";
+import {
+ DOWNLOAD_JDK_ACTION,
+ downloadJdk,
+ downloadJdkActions,
+ isDownloadJdkArgs,
+ requiredJdk,
+ TEMURIN,
+ type DownloadJdkArgs,
+} from "@/platform/jdk";
+import { useProject } from "@/platform/project";
+import { notifications } from "@/workbench/contributions";
+import { upsertTask } from "@/workbench/tasks";
+
+const JAVA_SETTINGS = "languages.java";
+const running = new Map<number, Promise<Sdk | null>>();
+
+/** Makes `home` the language server JDK if one that can't run jdtls is chosen (Auto finds the new JDK by itself). */
+export async function chooseForLanguageServer(home: string): Promise<void> {
+ const chosen = useProject.getState().settings?.languages?.java?.jdtlsJdk?.trim();
+ if (!chosen || chosen === home) return;
+ // The project value wins over the global one, so writing it there always takes effect.
+ const scope = useProject.getState().project ? "project" : "global";
+ const settings = await call(commands.settingsSet(scope, "languages.java.jdtlsJdk", JSON.stringify(home)));
+ useProject.setState({ settings });
+}
+
+export function downloadJdkFor(args: DownloadJdkArgs): Promise<Sdk | null> {
+ const existing = running.get(args.version);
+ if (existing) return existing;
+ const title = `Downloading JDK ${args.version}`;
+ const taskId = `jdk-download:${args.version}`;
+ const key = `jdk-download-${args.version}`;
+ const cancel = () => job.cancel();
+ const job = downloadJdk(TEMURIN, args.version, null, (e) => {
+ const message = e.type === "line" ? e.text : e.message;
+ const fraction = e.type === "progress" ? e.fraction : null;
+ upsertTask({ id: taskId, title, message, fraction, done: false, cancel });
+ });
+ upsertTask({ id: taskId, title, message: "Eclipse Temurin", fraction: null, done: false, cancel });
+ const p = (async () => {
+ try {
+ const sdk = await job.promise;
+ if (args.languageServer) await chooseForLanguageServer(sdk.path);
+ notifications().notify({
+ group: "tools",
+ level: "info",
+ key,
+ title: `${sdk.name} downloaded`,
+ body: args.languageServer
+ ? "The Java language server restarts on it."
+ : `Installed in ${sdk.path}; it is used for projects targeting Java ${args.version}.`,
+ });
+ return sdk;
+ } catch (e) {
+ if (isCancelled(e)) return null;
+ notifications().notify({
+ group: "tools",
+ level: "error",
+ key,
+ title: `Failed to download JDK ${args.version}`,
+ body: e instanceof Error ? e.message : String(e),
+ actions: [{ label: "Java Settings…", run: () => void executeAction("file.settings", JAVA_SETTINGS) }],
+ });
+ return null;
+ } finally {
+ upsertTask({ id: taskId, title, message: null, fraction: 1, done: true });
+ running.delete(args.version);
+ }
+ })();
+ running.set(args.version, p);
+ return p;
+}
+
+/** A language server that can't start without a newer JDK (jdtls): say so once, with the one-click download. */
+export function installJdkPrompts(): () => void {
+ const prompted = new Set<string>();
+ return onIdeEvent("languageServer", (e) => {
+ if (e.status !== "misconfigured") return;
+ const need = requiredJdk(e.message);
+ if (!need || prompted.has(`${e.name}:${need.version}`)) return;
+ prompted.add(`${e.name}:${need.version}`);
+ notifications().notify({
+ group: "lsp",
+ level: "warning",
+ key: `jdk-required-${e.name}`,
+ sticky: true,
+ title: `${e.name} needs JDK ${need.version} to run`,
+ body: e.message ?? undefined,
+ actions: [
+ ...downloadJdkActions(e.message),
+ { label: "Java Settings…", run: () => void executeAction("file.settings", JAVA_SETTINGS) },
+ ],
+ });
+ });
+}
+
+export function registerJdkActions(): () => void {
+ return registerActions([
+ {
+ id: DOWNLOAD_JDK_ACTION,
+ title: "Download JDK…",
+ category: "Java",
+ hidden: true,
+ // Without a version: the Java settings, whose JDK pickers offer Download JDK….
+ run: async ({ arg }) => {
+ if (isDownloadJdkArgs(arg) && isTauri()) await downloadJdkFor(arg);
+ else await executeAction("file.settings", JAVA_SETTINGS);
+ },
+ },
+ ]);
+}
diff --git a/src/platform/jdk.test.ts b/src/platform/jdk.test.ts
new file mode 100644
index 000000000..da541f25a
--- /dev/null
+++ b/src/platform/jdk.test.ts
@@ -0,0 +1,63 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const executeAction = vi.fn(async () => true);
+let registered = true;
+vi.mock("./actions", async (orig) => ({
+ ...(await orig<typeof import("./actions")>()),
+ executeAction,
+ getAction: (id: string) => (registered && id === "java.downloadJdk" ? { id } : undefined),
+}));
+
+const { downloadJdkActions, isDownloadJdkArgs, requiredJdk } = await import("./jdk");
+
+afterEach(() => {
+ registered = true;
+ vi.clearAllMocks();
+});
+
+// Issue #49, verbatim from the run console (Windows, JDK 8 / 17 / 21 installed).
+const ISSUE_49 =
+ "jdtls needs JDK 25 or newer to run (found JDK 8, 17, 21). Pick one in Settings › Languages & Frameworks › Java › Language Server › JDK (it restarts automatically), or install a newer JDK and restart the server; the project can still target an older Java version.";
+
+describe("JDK requirements in launch / sync errors", () => {
+ it.each([
+ [ISSUE_49, { version: 25, languageServer: true }],
+ [
+ "The language server JDK (C:\\Java\\jdk-21, JDK 21) is too old: jdtls needs JDK 25 or newer. Download JDK 25, choose another one in Settings › Languages & Frameworks › Java › Language Server › JDK, or set it to Auto.",
+ { version: 25, languageServer: true },
+ ],
+ [
+ "This project targets Java 21: it needs JDK 21 or newer (found JDK 17). Download JDK 21, or choose a Project JDK in Settings › Languages & Frameworks › Java.",
+ { version: 21, languageServer: false },
+ ],
+ [
+ "This project targets Java 17: it needs JDK 17 or newer (no JDK was found). Download JDK 17, or choose a Project JDK in Settings › Languages & Frameworks › Java.\n[ERROR] Failed to execute goal",
+ { version: 17, languageServer: false },
+ ],
+ ["The language server JDK /x is not a JDK home (Settings › Languages & Frameworks › Java).", null],
+ ["`rust-analyzer` was not found on PATH", null],
+ [null, null],
+ ])("%s", (message, expected) => {
+ expect(requiredJdk(message)).toEqual(expected);
+ });
+
+ it("offers Download JDK N, which runs the download action", () => {
+ const [fix, ...rest] = downloadJdkActions(ISSUE_49);
+ expect(rest).toEqual([]);
+ expect(fix!.label).toBe("Download JDK 25");
+ fix!.run();
+ expect(executeAction).toHaveBeenCalledWith("java.downloadJdk", { version: 25, languageServer: true });
+ expect(downloadJdkActions("jdtls crashed")).toEqual([]);
+ });
+
+ it("offers nothing where no window can download (e.g. without the tools feature)", () => {
+ registered = false;
+ expect(downloadJdkActions(ISSUE_49)).toEqual([]);
+ });
+
+ it("recognises the action's argument", () => {
+ expect(isDownloadJdkArgs({ version: 25 })).toBe(true);
+ expect(isDownloadJdkArgs({ version: "25" })).toBe(false);
+ expect(isDownloadJdkArgs(undefined)).toBe(false);
+ });
+});
diff --git a/src/platform/jdk.ts b/src/platform/jdk.ts
new file mode 100644
index 000000000..e0517311f
--- /dev/null
+++ b/src/platform/jdk.ts
@@ -0,0 +1,67 @@
+/**
+ * Download JDK (`jdk_download*` commands), shared by the JDK pickers in Settings
+ * and the "Download JDK N" fixes offered where a launch or sync lacks a JDK.
+ * The one-click fix is the `java.downloadJdk` action (features/tools).
+ */
+import { Channel } from "@tauri-apps/api/core";
+import { executeAction, getAction } from "./actions";
+import { call, commands, nextRequestId, type InstallEvent, type Sdk } from "./ipc";
+
+export const DOWNLOAD_JDK_ACTION = "java.downloadJdk";
+export const TEMURIN = "temurin";
+
+export interface DownloadJdkArgs {
+ /** Java feature version, e.g. 25. */
+ version: number;
+ /** Run jdtls on it: chosen as the language server JDK unless Auto already picks it. */
+ languageServer?: boolean;
+}
+
+export interface JdkRequirement {
+ version: number;
+ /** The JDK runs the Java language server (jdtls), not the project. */
+ languageServer: boolean;
+}
+
+/**
+ * The JDK a launch / sync error asks for: the backend's messages say
+ * "jdtls needs JDK 25 or newer" / "it needs JDK 21 or newer".
+ */
+export function requiredJdk(message: string | null | undefined): JdkRequirement | null {
+ const m = /needs JDK (\d+) or newer/.exec(message ?? "");
+ if (!m) return null;
+ return { version: Number(m[1]), languageServer: /\bjdtls\b|language server JDK/i.test(message ?? "") };
+}
+
+/** "Download JDK N" notification / banner actions for `message`; none when it names no JDK or nothing can download. */
+export function downloadJdkActions(message: string | null | undefined): Array<{ label: string; run: () => void }> {
+ const need = requiredJdk(message);
+ if (!need || !getAction(DOWNLOAD_JDK_ACTION)) return [];
+ const args: DownloadJdkArgs = { version: need.version, languageServer: need.languageServer };
+ return [{ label: `Download JDK ${need.version}`, run: () => void executeAction(DOWNLOAD_JDK_ACTION, args) }];
+}
+
+export function isDownloadJdkArgs(arg: unknown): arg is DownloadJdkArgs {
+ return !!arg && typeof arg === "object" && typeof (arg as { version?: unknown }).version === "number";
+}
+
+export interface JdkDownload {
+ promise: Promise<Sdk>;
+ cancel: () => void;
+}
+
+/** Downloads the latest `vendor` JDK `version` into `location` (null: the IDE's JDK folder). */
+export function downloadJdk(
+ vendor: string,
+ version: number,
+ location: string | null,
+ onEvent: (e: InstallEvent) => void,
+): JdkDownload {
+ const request = nextRequestId();
+ const channel = new Channel<InstallEvent>();
+ channel.onmessage = onEvent;
+ return {
+ promise: call(commands.jdkDownload(vendor, version, location, request, channel)),
+ cancel: () => void commands.cancelRequest(request).catch(() => {}),
+ };
+}