Skip to main content

rustjava_runtime/classes/java/io/
file_input_stream.rs

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