Skip to main content

rustjava_runtime/classes/java/net/
url.rs

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
16// class java.net.URL
17pub 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}