Skip to main content

rustjava_runtime/classes/java/net/
url_stream_handler.rs

1use alloc::{borrow::ToOwned, string::ToString, vec};
2
3use jvm_types::{ClassAccessFlags, MethodAccessFlags};
4use url::Url;
5
6use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
7use jvm_class_proto::JavaMethodProto;
8
9use crate::{
10    RuntimeClassProto, RuntimeContext,
11    classes::java::{lang::String, net::URL},
12};
13
14// abstract class java.net.URLStreamHandler
15pub struct URLStreamHandler;
16
17impl URLStreamHandler {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/net/URLStreamHandler",
21            parent_class: Some("java/lang/Object"),
22            interfaces: vec![],
23            methods: vec![
24                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
25                JavaMethodProto::new_abstract("openConnection", "(Ljava/net/URL;)Ljava/net/URLConnection;", MethodAccessFlags::PROTECTED),
26                JavaMethodProto::new(
27                    "parseURL",
28                    "(Ljava/net/URL;Ljava/lang/String;II)V",
29                    Self::parse_url,
30                    MethodAccessFlags::PROTECTED,
31                ),
32                JavaMethodProto::new(
33                    "setURL",
34                    "(Ljava/net/URL;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
35                    Self::set_url,
36                    MethodAccessFlags::PROTECTED,
37                ),
38            ],
39            fields: vec![],
40            access_flags: ClassAccessFlags::ABSTRACT,
41        }
42    }
43
44    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
45        tracing::debug!("java.net.URLStreamHandler::<init>({this:?})");
46
47        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
48
49        Ok(())
50    }
51
52    #[allow(clippy::too_many_arguments)]
53    async fn set_url(
54        jvm: &Jvm,
55        _: &mut RuntimeContext,
56        this: ClassInstanceRef<Self>,
57        url: ClassInstanceRef<URL>,
58        protocol: ClassInstanceRef<String>,
59        host: ClassInstanceRef<String>,
60        port: i32,
61        file: ClassInstanceRef<String>,
62        r#ref: ClassInstanceRef<String>,
63    ) -> Result<()> {
64        tracing::debug!(
65            "java.net.URLStreamHandler::setURL({this:?}, {url:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {:?})",
66            &r#ref
67        );
68
69        let _: () = jvm
70            .invoke_virtual(
71                &url,
72                "java/net/URL",
73                "set",
74                "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
75                (protocol, host, port, file, r#ref),
76            )
77            .await?;
78
79        Ok(())
80    }
81
82    async fn parse_url(
83        jvm: &Jvm,
84        _: &mut RuntimeContext,
85        this: ClassInstanceRef<Self>,
86        url: ClassInstanceRef<URL>,
87        spec: ClassInstanceRef<String>,
88        start: i32,
89        limit: i32,
90    ) -> Result<()> {
91        tracing::debug!("java.net.URLStreamHandler::parseURL({this:?}, {url:?}, {spec:?}, {start:?}, {limit:?})");
92
93        let spec_str = JavaLangString::to_rust_string(jvm, &spec).await?;
94
95        let parsed_url = Url::parse(&spec_str);
96        if let Err(x) = parsed_url {
97            return Err(jvm.exception("java/net/MalformedURLException", &x.to_string()).await);
98        }
99
100        let parsed_url = parsed_url.unwrap();
101
102        let protocol = parsed_url.scheme();
103        let path = parsed_url.path().to_owned() + &parsed_url.query().map(|x| "?".to_owned() + x).unwrap_or("".into());
104        let file = if protocol == "file" && spec_str.strip_prefix("file:").is_some_and(|file| !file.starts_with('/')) {
105            path.trim_start_matches('/')
106        } else {
107            &path
108        };
109
110        let protocol = JavaLangString::from_rust_string(jvm, parsed_url.scheme()).await?;
111        let host = JavaLangString::from_rust_string(jvm, parsed_url.host_str().unwrap_or("")).await?;
112        let port = parsed_url.port().map(|x| x as i32).unwrap_or(-1);
113        let file = JavaLangString::from_rust_string(jvm, file).await?;
114
115        let _: () = jvm
116            .invoke_virtual(
117                &this,
118                "java/net/URLStreamHandler",
119                "setURL",
120                "(Ljava/net/URL;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
121                (url, protocol, host, port, file, None),
122            )
123            .await?;
124
125        Ok(())
126    }
127}