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, "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}