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, "java/net/URL", "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, "java/net/URL", "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, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler)
207 .await?;
208 }
209
210 Ok(())
211 }
212
213 #[allow(clippy::too_many_arguments)]
214 async fn set(
215 jvm: &Jvm,
216 _: &mut RuntimeContext,
217 mut this: ClassInstanceRef<Self>,
218 protocol: ClassInstanceRef<String>,
219 host: ClassInstanceRef<String>,
220 port: i32,
221 file: ClassInstanceRef<String>,
222 r#ref: ClassInstanceRef<String>,
223 ) -> Result<()> {
224 tracing::debug!("java.net.URL::set({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {:?})", &r#ref);
225
226 jvm.put_field(&mut this, "java/net/URL", "protocol", "Ljava/lang/String;", protocol)
227 .await?;
228 jvm.put_field(&mut this, "java/net/URL", "host", "Ljava/lang/String;", host).await?;
229 jvm.put_field(&mut this, "java/net/URL", "port", "I", port).await?;
230 jvm.put_field(&mut this, "java/net/URL", "file", "Ljava/lang/String;", file).await?;
231
232 Ok(())
233 }
234
235 async fn open_connection(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<URLConnection>> {
236 tracing::debug!("java.net.URL::openConnection({this:?})");
237
238 let handler = jvm.get_field(&this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;").await?;
239 let connection = jvm
240 .invoke_virtual(
241 &handler,
242 "java/net/URLStreamHandler",
243 "openConnection",
244 "(Ljava/net/URL;)Ljava/net/URLConnection;",
245 (this,),
246 )
247 .await?;
248
249 Ok(connection)
250 }
251
252 async fn open_stream(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<InputStream>> {
253 tracing::debug!("java.net.URL::openStream({this:?})");
254
255 let connection = jvm
256 .invoke_virtual(&this, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
257 .await?;
258
259 let stream = jvm
260 .invoke_virtual(&connection, "java/net/URLConnection", "getInputStream", "()Ljava/io/InputStream;", ())
261 .await?;
262
263 Ok(stream)
264 }
265
266 async fn get_port(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
267 tracing::debug!("java.net.URL::getPort({this:?})");
268
269 let port = jvm.get_field(&this, "java/net/URL", "port", "I").await?;
270
271 Ok(port)
272 }
273
274 async fn get_protocol(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
275 tracing::debug!("java.net.URL::getProtocol({this:?})");
276
277 let protocol = jvm.get_field(&this, "java/net/URL", "protocol", "Ljava/lang/String;").await?;
278
279 Ok(protocol)
280 }
281
282 async fn get_host(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
283 tracing::debug!("java.net.URL::getHost({this:?})");
284
285 let host = jvm.get_field(&this, "java/net/URL", "host", "Ljava/lang/String;").await?;
286
287 Ok(host)
288 }
289
290 async fn get_file(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
291 tracing::debug!("java.net.URL::getFile({this:?})");
292
293 let file = jvm.get_field(&this, "java/net/URL", "file", "Ljava/lang/String;").await?;
294
295 Ok(file)
296 }
297
298 async fn get_handler(jvm: &Jvm, protocol: &str) -> Result<ClassInstanceRef<URLStreamHandler>> {
299 if protocol == "file" {
300 Ok(jvm.new_class("org/rustjava/net/FileURLHandler", "()V", ()).await?.into())
301 } else if protocol == "jar" {
302 Ok(jvm.new_class("org/rustjava/net/JarURLHandler", "()V", ()).await?.into())
303 } else {
304 Err(jvm
305 .exception("java/net/MalformedURLException", &format!("unknown protocol: {protocol}"))
306 .await)
307 }
308 }
309}