1use alloc::{format, vec};
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::{
10 io::InputStream,
11 lang::String,
12 net::{URLConnection, URLStreamHandler},
13 },
14};
15
16pub struct URL;
18
19impl URL {
20 pub fn as_proto() -> RuntimeClassProto {
21 RuntimeClassProto {
22 name: "java/net/URL",
23 parent_class: Some("java/lang/Object"),
24 interfaces: vec!["java/io/Serializable"],
25 methods: vec![
26 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_spec, MethodAccessFlags::PUBLIC),
27 JavaMethodProto::new(
28 "<init>",
29 "(Ljava/net/URL;Ljava/lang/String;)V",
30 Self::init_with_context_spec,
31 MethodAccessFlags::PUBLIC,
32 ),
33 JavaMethodProto::new(
34 "<init>",
35 "(Ljava/net/URL;Ljava/lang/String;Ljava/net/URLStreamHandler;)V",
36 Self::init_with_context_spec_handler,
37 MethodAccessFlags::PUBLIC,
38 ),
39 JavaMethodProto::new(
40 "<init>",
41 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
42 Self::init_with_protocol_host_file,
43 MethodAccessFlags::PUBLIC,
44 ),
45 JavaMethodProto::new(
46 "<init>",
47 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/net/URLStreamHandler;)V",
48 Self::init_with_protocol_host_port_file_handler,
49 MethodAccessFlags::PUBLIC,
50 ),
51 JavaMethodProto::new(
52 "openConnection",
53 "()Ljava/net/URLConnection;",
54 Self::open_connection,
55 MethodAccessFlags::PUBLIC,
56 ),
57 JavaMethodProto::new(
58 "openStream",
59 "()Ljava/io/InputStream;",
60 Self::open_stream,
61 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
62 ),
63 JavaMethodProto::new(
64 "set",
65 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
66 Self::set,
67 MethodAccessFlags::PROTECTED,
68 ),
69 JavaMethodProto::new("getPort", "()I", Self::get_port, MethodAccessFlags::PUBLIC),
70 JavaMethodProto::new("getProtocol", "()Ljava/lang/String;", Self::get_protocol, MethodAccessFlags::PUBLIC),
71 JavaMethodProto::new("getHost", "()Ljava/lang/String;", Self::get_host, MethodAccessFlags::PUBLIC),
72 JavaMethodProto::new("getFile", "()Ljava/lang/String;", Self::get_file, MethodAccessFlags::PUBLIC),
73 ],
74 fields: vec![
75 JavaFieldProto::new("protocol", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
76 JavaFieldProto::new("host", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
77 JavaFieldProto::new("port", "I", FieldAccessFlags::PRIVATE),
78 JavaFieldProto::new("file", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
79 JavaFieldProto::new("handler", "Ljava/net/URLStreamHandler;", FieldAccessFlags::TRANSIENT),
80 ],
81 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
82 }
83 }
84
85 async fn init_with_spec(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, spec: ClassInstanceRef<String>) -> Result<()> {
86 tracing::debug!("java.net.URL::<init>({this:?}, {spec:?})");
87
88 let _: () = jvm
89 .invoke_special(&this, "java/net/URL", "<init>", "(Ljava/net/URL;Ljava/lang/String;)V", (None, spec))
90 .await?;
91
92 Ok(())
93 }
94
95 async fn init_with_context_spec(
96 jvm: &Jvm,
97 _: &mut RuntimeContext,
98 this: ClassInstanceRef<Self>,
99 context: ClassInstanceRef<URL>,
100 spec: ClassInstanceRef<String>,
101 ) -> Result<()> {
102 tracing::debug!("java.net.URL::<init>({this:?}, {context:?}, {spec:?})");
103
104 let _: () = jvm
105 .invoke_special(
106 &this,
107 "java/net/URL",
108 "<init>",
109 "(Ljava/net/URL;Ljava/lang/String;Ljava/net/URLStreamHandler;)V",
110 (context, spec, None),
111 )
112 .await?;
113
114 Ok(())
115 }
116
117 async fn init_with_context_spec_handler(
118 jvm: &Jvm,
119 _: &mut RuntimeContext,
120 mut this: ClassInstanceRef<Self>,
121 context: ClassInstanceRef<URL>,
122 spec: ClassInstanceRef<String>,
123 handler: ClassInstanceRef<URLStreamHandler>,
124 ) -> Result<()> {
125 tracing::debug!("java.net.URL::<init>({this:?}, {context:?}, {spec:?}, {handler:?})");
126
127 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
128
129 let spec_str = JavaLangString::to_rust_string(jvm, &spec).await?;
130
131 let protocol = spec_str.split(':').next().unwrap_or_default();
132
133 let handler = Self::get_handler(jvm, protocol).await?;
134
135 jvm.put_field(&mut this, "handler", "Ljava/net/URLStreamHandler;", handler.clone())
136 .await?;
137
138 let _: () = jvm
139 .invoke_virtual(
140 &handler,
141 "java/net/URLStreamHandler",
142 "parseURL",
143 "(Ljava/net/URL;Ljava/lang/String;II)V",
144 (this, spec, 0, spec_str.len() as i32),
145 )
146 .await?;
147
148 Ok(())
149 }
150
151 async fn init_with_protocol_host_file(
152 jvm: &Jvm,
153 _: &mut RuntimeContext,
154 this: ClassInstanceRef<Self>,
155 protocol: ClassInstanceRef<String>,
156 host: ClassInstanceRef<String>,
157 file: ClassInstanceRef<String>,
158 ) -> Result<()> {
159 tracing::debug!("java.net.URL::<init>({this:?}, {protocol:?}, {host:?}, {file:?})");
160
161 let _: () = jvm
162 .invoke_special(
163 &this,
164 "java/net/URL",
165 "<init>",
166 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/net/URLStreamHandler;)V",
167 (protocol, host, -1, file, None),
168 )
169 .await?;
170
171 Ok(())
172 }
173
174 #[allow(clippy::too_many_arguments)]
175 async fn init_with_protocol_host_port_file_handler(
176 jvm: &Jvm,
177 _: &mut RuntimeContext,
178 mut this: ClassInstanceRef<Self>,
179 protocol: ClassInstanceRef<String>,
180 host: ClassInstanceRef<String>,
181 port: i32,
182 file: ClassInstanceRef<String>,
183 handler: ClassInstanceRef<URLStreamHandler>,
184 ) -> Result<()> {
185 tracing::debug!("java.net.URL::<init>({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {handler:?})");
186
187 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
188
189 jvm.put_field(&mut this, "handler", "Ljava/net/URLStreamHandler;", handler.clone())
190 .await?;
191
192 let _: () = jvm
193 .invoke_virtual(
194 &this,
195 "java/net/URL",
196 "set",
197 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
198 (protocol.clone(), host, port, file, None),
199 )
200 .await?;
201
202 if handler.is_null() {
203 let protocol = JavaLangString::to_rust_string(jvm, &protocol).await?;
204 let handler = Self::get_handler(jvm, &protocol).await?;
205
206 jvm.put_field(&mut this, "handler", "Ljava/net/URLStreamHandler;", handler).await?;
207 }
208
209 Ok(())
210 }
211
212 #[allow(clippy::too_many_arguments)]
213 async fn set(
214 jvm: &Jvm,
215 _: &mut RuntimeContext,
216 mut this: ClassInstanceRef<Self>,
217 protocol: ClassInstanceRef<String>,
218 host: ClassInstanceRef<String>,
219 port: i32,
220 file: ClassInstanceRef<String>,
221 r#ref: ClassInstanceRef<String>,
222 ) -> Result<()> {
223 tracing::debug!("java.net.URL::set({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {:?})", &r#ref);
224
225 jvm.put_field(&mut this, "protocol", "Ljava/lang/String;", protocol).await?;
226 jvm.put_field(&mut this, "host", "Ljava/lang/String;", host).await?;
227 jvm.put_field(&mut this, "port", "I", port).await?;
228 jvm.put_field(&mut this, "file", "Ljava/lang/String;", file).await?;
229
230 Ok(())
231 }
232
233 async fn open_connection(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<URLConnection>> {
234 tracing::debug!("java.net.URL::openConnection({this:?})");
235
236 let handler = jvm.get_field(&this, "handler", "Ljava/net/URLStreamHandler;").await?;
237 let connection = jvm
238 .invoke_virtual(
239 &handler,
240 "java/net/URLStreamHandler",
241 "openConnection",
242 "(Ljava/net/URL;)Ljava/net/URLConnection;",
243 (this,),
244 )
245 .await?;
246
247 Ok(connection)
248 }
249
250 async fn open_stream(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<InputStream>> {
251 tracing::debug!("java.net.URL::openStream({this:?})");
252
253 let connection = jvm
254 .invoke_virtual(&this, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
255 .await?;
256
257 let stream = jvm
258 .invoke_virtual(&connection, "java/net/URLConnection", "getInputStream", "()Ljava/io/InputStream;", ())
259 .await?;
260
261 Ok(stream)
262 }
263
264 async fn get_port(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
265 tracing::debug!("java.net.URL::getPort({this:?})");
266
267 let port = jvm.get_field(&this, "port", "I").await?;
268
269 Ok(port)
270 }
271
272 async fn get_protocol(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
273 tracing::debug!("java.net.URL::getProtocol({this:?})");
274
275 let protocol = jvm.get_field(&this, "protocol", "Ljava/lang/String;").await?;
276
277 Ok(protocol)
278 }
279
280 async fn get_host(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
281 tracing::debug!("java.net.URL::getHost({this:?})");
282
283 let host = jvm.get_field(&this, "host", "Ljava/lang/String;").await?;
284
285 Ok(host)
286 }
287
288 async fn get_file(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
289 tracing::debug!("java.net.URL::getFile({this:?})");
290
291 let file = jvm.get_field(&this, "file", "Ljava/lang/String;").await?;
292
293 Ok(file)
294 }
295
296 async fn get_handler(jvm: &Jvm, protocol: &str) -> Result<ClassInstanceRef<URLStreamHandler>> {
297 if protocol == "file" {
298 Ok(jvm.new_class("org/rustjava/net/FileURLHandler", "()V", ()).await?.into())
299 } else if protocol == "jar" {
300 Ok(jvm.new_class("org/rustjava/net/JarURLHandler", "()V", ()).await?.into())
301 } else {
302 Err(jvm
303 .exception("java/net/MalformedURLException", &format!("unknown protocol: {protocol}"))
304 .await)
305 }
306 }
307}