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        if spec.is_null() {
128            return Err(jvm.exception("java/net/MalformedURLException", "spec is null").await);
129        }
130
131        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
132
133        let spec_str = JavaLangString::to_rust_string(jvm, &spec).await?;
134
135        let protocol = spec_str.split(':').next().unwrap_or_default();
136
137        let handler = Self::get_handler(jvm, protocol).await?;
138
139        jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler.clone())
140            .await?;
141
142        let _: () = jvm
143            .invoke_virtual(
144                &handler,
145                "java/net/URLStreamHandler",
146                "parseURL",
147                "(Ljava/net/URL;Ljava/lang/String;II)V",
148                (this, spec, 0, spec_str.len() as i32),
149            )
150            .await?;
151
152        Ok(())
153    }
154
155    async fn init_with_protocol_host_file(
156        jvm: &Jvm,
157        _: &mut RuntimeContext,
158        this: ClassInstanceRef<Self>,
159        protocol: ClassInstanceRef<String>,
160        host: ClassInstanceRef<String>,
161        file: ClassInstanceRef<String>,
162    ) -> Result<()> {
163        tracing::debug!("java.net.URL::<init>({this:?}, {protocol:?}, {host:?}, {file:?})");
164
165        let _: () = jvm
166            .invoke_special(
167                &this,
168                "java/net/URL",
169                "<init>",
170                "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/net/URLStreamHandler;)V",
171                (protocol, host, -1, file, None),
172            )
173            .await?;
174
175        Ok(())
176    }
177
178    #[allow(clippy::too_many_arguments)]
179    async fn init_with_protocol_host_port_file_handler(
180        jvm: &Jvm,
181        _: &mut RuntimeContext,
182        mut this: ClassInstanceRef<Self>,
183        protocol: ClassInstanceRef<String>,
184        host: ClassInstanceRef<String>,
185        port: i32,
186        file: ClassInstanceRef<String>,
187        handler: ClassInstanceRef<URLStreamHandler>,
188    ) -> Result<()> {
189        tracing::debug!("java.net.URL::<init>({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {handler:?})");
190
191        if protocol.is_null() || file.is_null() {
192            return Err(jvm.exception("java/lang/NullPointerException", "protocol or file is null").await);
193        }
194
195        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
196
197        jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler.clone())
198            .await?;
199
200        let _: () = jvm
201            .invoke_virtual(
202                &this,
203                "java/net/URL",
204                "set",
205                "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
206                (protocol.clone(), host, port, file, None),
207            )
208            .await?;
209
210        if handler.is_null() {
211            let protocol = JavaLangString::to_rust_string(jvm, &protocol).await?;
212            let handler = Self::get_handler(jvm, &protocol).await?;
213
214            jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler)
215                .await?;
216        }
217
218        Ok(())
219    }
220
221    #[allow(clippy::too_many_arguments)]
222    async fn set(
223        jvm: &Jvm,
224        _: &mut RuntimeContext,
225        mut this: ClassInstanceRef<Self>,
226        protocol: ClassInstanceRef<String>,
227        host: ClassInstanceRef<String>,
228        port: i32,
229        file: ClassInstanceRef<String>,
230        r#ref: ClassInstanceRef<String>,
231    ) -> Result<()> {
232        tracing::debug!("java.net.URL::set({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {:?})", &r#ref);
233
234        jvm.put_field(&mut this, "java/net/URL", "protocol", "Ljava/lang/String;", protocol)
235            .await?;
236        jvm.put_field(&mut this, "java/net/URL", "host", "Ljava/lang/String;", host).await?;
237        jvm.put_field(&mut this, "java/net/URL", "port", "I", port).await?;
238        jvm.put_field(&mut this, "java/net/URL", "file", "Ljava/lang/String;", file).await?;
239
240        Ok(())
241    }
242
243    async fn open_connection(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<URLConnection>> {
244        tracing::debug!("java.net.URL::openConnection({this:?})");
245
246        let handler = jvm.get_field(&this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;").await?;
247        let connection = jvm
248            .invoke_virtual(
249                &handler,
250                "java/net/URLStreamHandler",
251                "openConnection",
252                "(Ljava/net/URL;)Ljava/net/URLConnection;",
253                (this,),
254            )
255            .await?;
256
257        Ok(connection)
258    }
259
260    async fn open_stream(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<InputStream>> {
261        tracing::debug!("java.net.URL::openStream({this:?})");
262
263        let connection = jvm
264            .invoke_virtual(&this, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
265            .await?;
266
267        let stream = jvm
268            .invoke_virtual(&connection, "java/net/URLConnection", "getInputStream", "()Ljava/io/InputStream;", ())
269            .await?;
270
271        Ok(stream)
272    }
273
274    async fn get_port(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
275        tracing::debug!("java.net.URL::getPort({this:?})");
276
277        let port = jvm.get_field(&this, "java/net/URL", "port", "I").await?;
278
279        Ok(port)
280    }
281
282    async fn get_protocol(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
283        tracing::debug!("java.net.URL::getProtocol({this:?})");
284
285        let protocol = jvm.get_field(&this, "java/net/URL", "protocol", "Ljava/lang/String;").await?;
286
287        Ok(protocol)
288    }
289
290    async fn get_host(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
291        tracing::debug!("java.net.URL::getHost({this:?})");
292
293        let host = jvm.get_field(&this, "java/net/URL", "host", "Ljava/lang/String;").await?;
294
295        Ok(host)
296    }
297
298    async fn get_file(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
299        tracing::debug!("java.net.URL::getFile({this:?})");
300
301        let file = jvm.get_field(&this, "java/net/URL", "file", "Ljava/lang/String;").await?;
302
303        Ok(file)
304    }
305
306    async fn get_handler(jvm: &Jvm, protocol: &str) -> Result<ClassInstanceRef<URLStreamHandler>> {
307        if protocol == "file" {
308            Ok(jvm.new_class("org/rustjava/net/FileURLHandler", "()V", ()).await?.into())
309        } else if protocol == "jar" {
310            Ok(jvm.new_class("org/rustjava/net/JarURLHandler", "()V", ()).await?.into())
311        } else {
312            Err(jvm
313                .exception("java/net/MalformedURLException", &format!("unknown protocol: {protocol}"))
314                .await)
315        }
316    }
317}