use alloc::{format, vec, vec::Vec};
use jvm::{
Array, ClassInstanceRef, Jvm, Result,
runtime::{JavaIoInputStream, JavaLangString},
};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::{
FileType, RuntimeClassProto, RuntimeContext,
classes::java::{
lang::{Class, ClassLoader, String},
net::{JarURLConnection, URL},
util::jar::JarEntry,
},
};
pub struct URLClassLoader;
impl URLClassLoader {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/net/URLClassLoader",
parent_class: Some("java/lang/ClassLoader"), interfaces: vec![],
methods: vec![
JavaMethodProto::new(
"<init>",
"([Ljava/net/URL;Ljava/lang/ClassLoader;)V",
Self::init,
MethodAccessFlags::PUBLIC,
),
JavaMethodProto::new(
"findClass",
"(Ljava/lang/String;)Ljava/lang/Class;",
Self::find_class,
MethodAccessFlags::PROTECTED,
),
JavaMethodProto::new(
"findResource",
"(Ljava/lang/String;)Ljava/net/URL;",
Self::find_resource,
MethodAccessFlags::PUBLIC,
),
],
fields: vec![JavaFieldProto::new("urls", "[Ljava/net/URL;", FieldAccessFlags::PRIVATE)],
access_flags: ClassAccessFlags::PUBLIC,
}
}
async fn init(
jvm: &Jvm,
_: &mut RuntimeContext,
mut this: ClassInstanceRef<Self>,
urls: ClassInstanceRef<Array<URL>>,
parent: ClassInstanceRef<ClassLoader>,
) -> Result<()> {
tracing::debug!("java.net.URLClassLoader::<init>({this:?}, {urls:?}, {parent:?})");
let _: () = jvm
.invoke_special(&this, "java/lang/ClassLoader", "<init>", "(Ljava/lang/ClassLoader;)V", (parent,))
.await?;
jvm.put_field(&mut this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;", urls)
.await?;
Ok(())
}
async fn find_class(
jvm: &Jvm,
_: &mut RuntimeContext,
this: ClassInstanceRef<Self>,
name: ClassInstanceRef<String>,
) -> Result<ClassInstanceRef<Class>> {
tracing::debug!("java.net.URLClassLoader::findClass({this:?}, {name:?})");
let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
let resource_name = format!("{}.class", name_str.replace('.', "/"));
let resource_name = JavaLangString::from_rust_string(jvm, &resource_name).await?;
let resource: ClassInstanceRef<URL> = jvm
.invoke_virtual(
&this,
"java/net/URLClassLoader",
"findResource",
"(Ljava/lang/String;)Ljava/net/URL;",
(resource_name,),
)
.await?;
if resource.is_null() {
return Ok(None.into());
}
let stream = jvm
.invoke_virtual(&resource, "java/net/URL", "openStream", "()Ljava/io/InputStream;", ())
.await?;
let bytes = JavaIoInputStream::read_until_end(jvm, &stream).await?;
let length = bytes.len() as i32;
let mut bytes_java = jvm.instantiate_array("B", bytes.len()).await?;
jvm.array_raw_buffer_mut(&mut bytes_java).await?.write(0, &bytes)?;
let class = jvm
.invoke_virtual(
&this,
"java/net/URLClassLoader",
"defineClass",
"(Ljava/lang/String;[BII)Ljava/lang/Class;",
(name, bytes_java.clone(), 0, length),
)
.await?;
Ok(class)
}
async fn find_resource(
jvm: &Jvm,
runtime: &mut RuntimeContext,
this: ClassInstanceRef<Self>,
name: ClassInstanceRef<String>,
) -> Result<ClassInstanceRef<URL>> {
tracing::debug!("java.net.URLClassLoader::findResource({this:?}, {name:?})");
let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
let urls = jvm.get_field(&this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;").await?;
let urls: Vec<ClassInstanceRef<URL>> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?;
for url in urls {
let file: ClassInstanceRef<String> = jvm.invoke_virtual(&url, "java/net/URL", "getFile", "()Ljava/lang/String;", ()).await?;
let path = jvm
.invoke_static(
"org/rustjava/net/URLPath",
"decode",
"(Ljava/lang/String;)Ljava/lang/String;",
(file.clone(),),
)
.await?;
let file = JavaLangString::to_rust_string(jvm, &file).await?;
let path = JavaLangString::to_rust_string(jvm, &path).await?;
let metadata = runtime.metadata(&path).await;
if path.ends_with('/') || path.is_empty() || metadata.as_ref().is_ok_and(|metadata| metadata.r#type == FileType::Directory) {
let final_path = if path.is_empty() {
name_str.clone()
} else if path.ends_with('/') {
format!("{path}{name_str}")
} else {
format!("{path}/{name_str}")
};
if runtime.metadata(&final_path).await.is_ok() {
let final_path = JavaLangString::from_rust_string(jvm, &final_path).await?;
let final_path: ClassInstanceRef<String> = jvm
.invoke_static(
"org/rustjava/net/URLPath",
"encode",
"(Ljava/lang/String;)Ljava/lang/String;",
(final_path,),
)
.await?;
let new_url = jvm
.new_class(
"java/net/URL",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
(
JavaLangString::from_rust_string(jvm, "file").await?,
JavaLangString::from_rust_string(jvm, "").await?,
final_path,
),
)
.await?;
return Ok(new_url.into());
}
} else if metadata.is_err() {
continue;
} else {
let name_str = name_str.trim_start_matches('/');
let entry = JavaLangString::from_rust_string(jvm, name_str).await?;
let entry = jvm
.invoke_static("org/rustjava/net/URLPath", "encode", "(Ljava/lang/String;)Ljava/lang/String;", (entry,))
.await?;
let entry = JavaLangString::to_rust_string(jvm, &entry).await?;
let jar_url_str = format!("jar:file:{file}!/{entry}"); let jar_url = JavaLangString::from_rust_string(jvm, &jar_url_str).await?;
let jar_url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (jar_url,)).await?;
let connection: ClassInstanceRef<JarURLConnection> = jvm
.invoke_virtual(&jar_url, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
.await?;
let entry: ClassInstanceRef<JarEntry> = jvm
.invoke_virtual(&connection, "java/net/JarURLConnection", "getJarEntry", "()Ljava/util/jar/JarEntry;", ())
.await?;
if !entry.is_null() {
return Ok(jar_url.into());
}
}
}
Ok(None.into())
}
}