rustjava_runtime/classes/java/net/
url_stream_handler.rs1use alloc::{borrow::ToOwned, string::ToString, vec};
2
3use jvm_types::{ClassAccessFlags, MethodAccessFlags};
4use url::Url;
5
6use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
7use jvm_class_proto::JavaMethodProto;
8
9use crate::{
10 RuntimeClassProto, RuntimeContext,
11 classes::java::{lang::String, net::URL},
12};
13
14pub struct URLStreamHandler;
16
17impl URLStreamHandler {
18 pub fn as_proto() -> RuntimeClassProto {
19 RuntimeClassProto {
20 name: "java/net/URLStreamHandler",
21 parent_class: Some("java/lang/Object"),
22 interfaces: vec![],
23 methods: vec![
24 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
25 JavaMethodProto::new_abstract("openConnection", "(Ljava/net/URL;)Ljava/net/URLConnection;", MethodAccessFlags::PROTECTED),
26 JavaMethodProto::new(
27 "parseURL",
28 "(Ljava/net/URL;Ljava/lang/String;II)V",
29 Self::parse_url,
30 MethodAccessFlags::PROTECTED,
31 ),
32 JavaMethodProto::new(
33 "setURL",
34 "(Ljava/net/URL;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
35 Self::set_url,
36 MethodAccessFlags::PROTECTED,
37 ),
38 ],
39 fields: vec![],
40 access_flags: ClassAccessFlags::ABSTRACT,
41 }
42 }
43
44 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
45 tracing::debug!("java.net.URLStreamHandler::<init>({this:?})");
46
47 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
48
49 Ok(())
50 }
51
52 #[allow(clippy::too_many_arguments)]
53 async fn set_url(
54 jvm: &Jvm,
55 _: &mut RuntimeContext,
56 this: ClassInstanceRef<Self>,
57 url: ClassInstanceRef<URL>,
58 protocol: ClassInstanceRef<String>,
59 host: ClassInstanceRef<String>,
60 port: i32,
61 file: ClassInstanceRef<String>,
62 r#ref: ClassInstanceRef<String>,
63 ) -> Result<()> {
64 tracing::debug!(
65 "java.net.URLStreamHandler::setURL({this:?}, {url:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {:?})",
66 &r#ref
67 );
68
69 let _: () = jvm
70 .invoke_virtual(
71 &url,
72 "java/net/URL",
73 "set",
74 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
75 (protocol, host, port, file, r#ref),
76 )
77 .await?;
78
79 Ok(())
80 }
81
82 async fn parse_url(
83 jvm: &Jvm,
84 _: &mut RuntimeContext,
85 this: ClassInstanceRef<Self>,
86 url: ClassInstanceRef<URL>,
87 spec: ClassInstanceRef<String>,
88 start: i32,
89 limit: i32,
90 ) -> Result<()> {
91 tracing::debug!("java.net.URLStreamHandler::parseURL({this:?}, {url:?}, {spec:?}, {start:?}, {limit:?})");
92
93 let spec_str = JavaLangString::to_rust_string(jvm, &spec).await?;
94
95 let parsed_url = Url::parse(&spec_str);
96 if let Err(x) = parsed_url {
97 return Err(jvm.exception("java/net/MalformedURLException", &x.to_string()).await);
98 }
99
100 let parsed_url = parsed_url.unwrap();
101
102 let protocol = parsed_url.scheme();
103 let path = parsed_url.path().to_owned() + &parsed_url.query().map(|x| "?".to_owned() + x).unwrap_or("".into());
104 let file = if protocol == "file" && spec_str.strip_prefix("file:").is_some_and(|file| !file.starts_with('/')) {
105 path.trim_start_matches('/')
106 } else {
107 &path
108 };
109
110 let protocol = JavaLangString::from_rust_string(jvm, parsed_url.scheme()).await?;
111 let host = JavaLangString::from_rust_string(jvm, parsed_url.host_str().unwrap_or("")).await?;
112 let port = parsed_url.port().map(|x| x as i32).unwrap_or(-1);
113 let file = JavaLangString::from_rust_string(jvm, file).await?;
114
115 let _: () = jvm
116 .invoke_virtual(
117 &this,
118 "java/net/URLStreamHandler",
119 "setURL",
120 "(Ljava/net/URL;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
121 (url, protocol, host, port, file, None),
122 )
123 .await?;
124
125 Ok(())
126 }
127}