Skip to main content

rustjava_runtime/classes/java/io/
file_input_stream.rs

1use alloc::vec;
2
3use bytemuck::cast_vec;
4
5use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    FileOpenOptions, RuntimeClassProto, RuntimeContext,
11    classes::java::io::{File, FileDescriptor},
12};
13
14// class java.io.FileInputStream
15pub struct FileInputStream;
16
17impl FileInputStream {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/io/FileInputStream",
21            parent_class: Some("java/io/InputStream"),
22            interfaces: vec![],
23            methods: vec![
24                JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new(
26                    "<init>",
27                    "(Ljava/io/FileDescriptor;)V",
28                    Self::init_with_file_descriptor,
29                    MethodAccessFlags::PUBLIC,
30                ),
31                JavaMethodProto::new("read", "()I", Self::read_byte, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new("read", "([BII)I", Self::read_array, MethodAccessFlags::PUBLIC),
33                JavaMethodProto::new("available", "()I", Self::available, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
35            ],
36            fields: vec![JavaFieldProto::new(
37                "fd",
38                "Ljava/io/FileDescriptor;",
39                FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL,
40            )],
41            access_flags: ClassAccessFlags::PUBLIC,
42        }
43    }
44
45    async fn init(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
46        tracing::debug!("java.io.FileInputStream::<init>({this:?}, {file:?})");
47        if file.is_null() {
48            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
49        }
50
51        let path = jvm.invoke_virtual(&file, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
52        let path = JavaLangString::to_rust_string(jvm, &path).await?;
53
54        let fd = context
55            .open(
56                &path,
57                FileOpenOptions {
58                    read: true,
59                    ..Default::default()
60                },
61            )
62            .await;
63        if fd.is_err() {
64            return Err(jvm.exception("java/io/FileNotFoundException", "File not found").await);
65        }
66
67        let fd = FileDescriptor::from_fd(jvm, fd.unwrap()).await?;
68
69        let _: () = jvm
70            .invoke_special(&this, "java/io/FileInputStream", "<init>", "(Ljava/io/FileDescriptor;)V", (fd,))
71            .await?;
72
73        Ok(())
74    }
75
76    async fn init_with_file_descriptor(
77        jvm: &Jvm,
78        _: &mut RuntimeContext,
79        mut this: ClassInstanceRef<Self>,
80        fd: ClassInstanceRef<FileDescriptor>,
81    ) -> Result<()> {
82        tracing::debug!("java.io.FileInputStream::<init>({this:?}, {fd:?})");
83        if fd.is_null() {
84            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
85        }
86
87        let _: () = jvm.invoke_special(&this, "java/io/InputStream", "<init>", "()V", ()).await?;
88
89        jvm.put_field(&mut this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;", fd)
90            .await?;
91
92        Ok(())
93    }
94
95    async fn available(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
96        tracing::debug!("java.io.FileInputStream::available({this:?})");
97
98        let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?;
99        let rust_file = FileDescriptor::file(jvm, context, fd).await?;
100
101        // TODO get os buffer size
102        let Ok(stat) = rust_file.metadata().await else {
103            return Err(jvm.exception("java/io/IOException", "I/O error").await);
104        };
105        let Ok(tell) = rust_file.tell().await else {
106            return Err(jvm.exception("java/io/IOException", "I/O error").await);
107        };
108
109        let available = stat.size - tell;
110
111        Ok(available as _)
112    }
113
114    async fn read_array(
115        jvm: &Jvm,
116        context: &mut RuntimeContext,
117        this: ClassInstanceRef<Self>,
118        mut buf: ClassInstanceRef<Array<i8>>,
119        offset: i32,
120        length: i32,
121    ) -> Result<i32> {
122        tracing::debug!("java.io.FileInputStream::read({this:?}, {buf:?}, {offset:?}, {length:?})");
123        if buf.is_null() {
124            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
125        }
126
127        let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?;
128        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
129
130        let mut rust_buf = vec![0; length as _];
131        let Ok(read) = rust_file.read(&mut rust_buf).await else {
132            return Err(jvm.exception("java/io/IOException", "I/O error").await);
133        };
134        if read == 0 {
135            return Ok(-1);
136        }
137
138        jvm.store_array(&mut buf, offset as _, cast_vec::<u8, i8>(rust_buf)).await?;
139
140        Ok(read as _)
141    }
142
143    async fn read_byte(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
144        tracing::debug!("java.io.FileInputStream::read({this:?})");
145
146        let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?;
147        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
148
149        let mut buf = [0; 1];
150        let Ok(read) = rust_file.read(&mut buf).await else {
151            return Err(jvm.exception("java/io/IOException", "I/O error").await);
152        };
153        if read == 0 {
154            return Ok(-1);
155        }
156
157        Ok(buf[0] as i32)
158    }
159
160    async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
161        tracing::debug!("java.io.FileInputStream::close({this:?})");
162
163        let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?;
164        FileDescriptor::close(jvm, context, fd).await?;
165
166        Ok(())
167    }
168}