rustjava_runtime/classes/java/io/
file_input_stream.rs1use 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
12pub 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 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}