1use alloc::vec;
2
3use jvm::{ClassInstanceRef, JavaError, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::{
10 io::{OutputStream, OutputStreamWriter},
11 lang::{Exception, String},
12 },
13};
14
15use super::{Formatter, Level, LogRecord, SimpleFormatter};
16
17pub struct StreamHandler;
19
20impl StreamHandler {
21 pub fn as_proto() -> RuntimeClassProto {
22 RuntimeClassProto {
23 name: "java/util/logging/StreamHandler",
24 parent_class: Some("java/util/logging/Handler"),
25 interfaces: vec![],
26 methods: vec![
27 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new(
29 "<init>",
30 "(Ljava/io/OutputStream;Ljava/util/logging/Formatter;)V",
31 Self::init_with_output,
32 MethodAccessFlags::PUBLIC,
33 ),
34 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
35 JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
36 JavaMethodProto::new(
37 "isLoggable",
38 "(Ljava/util/logging/LogRecord;)Z",
39 Self::is_loggable,
40 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
41 ),
42 JavaMethodProto::new(
43 "publish",
44 "(Ljava/util/logging/LogRecord;)V",
45 Self::publish,
46 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
47 ),
48 JavaMethodProto::new(
49 "setEncoding",
50 "(Ljava/lang/String;)V",
51 Self::set_encoding,
52 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
53 ),
54 JavaMethodProto::new(
55 "setOutputStream",
56 "(Ljava/io/OutputStream;)V",
57 Self::set_output_stream,
58 MethodAccessFlags::PROTECTED | MethodAccessFlags::SYNCHRONIZED,
59 ),
60 ],
61 fields: vec![
62 JavaFieldProto::new("output", "Ljava/io/OutputStream;", FieldAccessFlags::PRIVATE),
63 JavaFieldProto::new("writer", "Ljava/io/OutputStreamWriter;", FieldAccessFlags::PRIVATE),
64 JavaFieldProto::new("headerWritten", "Z", FieldAccessFlags::PRIVATE),
65 ],
66 access_flags: ClassAccessFlags::PUBLIC,
67 }
68 }
69
70 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
71 tracing::debug!("java.util.logging.StreamHandler::<init>({this:?})");
72
73 let _: () = jvm.invoke_special(&this, "java/util/logging/Handler", "<init>", "()V", ()).await?;
74 let formatter: ClassInstanceRef<SimpleFormatter> = jvm.new_class("java/util/logging/SimpleFormatter", "()V", ()).await?.into();
75 let level: ClassInstanceRef<Level> = jvm
76 .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
77 .await?;
78 let _: () = jvm
79 .invoke_special(
80 &this,
81 "java/util/logging/Handler",
82 "setFormatter",
83 "(Ljava/util/logging/Formatter;)V",
84 (formatter,),
85 )
86 .await?;
87 let _: () = jvm
88 .invoke_special(&this, "java/util/logging/Handler", "setLevel", "(Ljava/util/logging/Level;)V", (level,))
89 .await?;
90 jvm.put_field(&mut this, "headerWritten", "Z", false).await
91 }
92
93 async fn init_with_output(
94 jvm: &Jvm,
95 _: &mut RuntimeContext,
96 this: ClassInstanceRef<Self>,
97 output: ClassInstanceRef<OutputStream>,
98 formatter: ClassInstanceRef<Formatter>,
99 ) -> Result<()> {
100 tracing::debug!("java.util.logging.StreamHandler::<init>({this:?}, {output:?}, {formatter:?})");
101
102 if output.is_null() {
103 return Err(jvm.exception("java/lang/NullPointerException", "output").await);
104 }
105 if formatter.is_null() {
106 return Err(jvm.exception("java/lang/NullPointerException", "formatter").await);
107 }
108
109 let _: () = jvm.invoke_special(&this, "java/util/logging/StreamHandler", "<init>", "()V", ()).await?;
110 let _: () = jvm
111 .invoke_special(
112 &this,
113 "java/util/logging/Handler",
114 "setFormatter",
115 "(Ljava/util/logging/Formatter;)V",
116 (formatter,),
117 )
118 .await?;
119 jvm.invoke_special(
120 &this,
121 "java/util/logging/StreamHandler",
122 "setOutputStream",
123 "(Ljava/io/OutputStream;)V",
124 (output,),
125 )
126 .await
127 }
128
129 async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
130 tracing::debug!("java.util.logging.StreamHandler::close({this:?})");
131
132 let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
133 if writer.is_null() {
134 return Ok(());
135 }
136
137 Self::write_tail(jvm, &this).await?;
138 let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
139 let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "close", "()V", ()).await?;
140 let output: ClassInstanceRef<OutputStream> = None.into();
141 let writer: ClassInstanceRef<OutputStreamWriter> = None.into();
142 jvm.put_field(&mut this, "output", "Ljava/io/OutputStream;", output).await?;
143 jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await?;
144 jvm.put_field(&mut this, "headerWritten", "Z", false).await
145 }
146
147 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
148 tracing::debug!("java.util.logging.StreamHandler::flush({this:?})");
149
150 let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
151 if writer.is_null() {
152 return Ok(());
153 }
154 jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await
155 }
156
157 async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<bool> {
158 tracing::debug!("java.util.logging.StreamHandler::isLoggable({this:?}, {record:?})");
159
160 let output: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "output", "Ljava/io/OutputStream;").await?;
161 if output.is_null() || record.is_null() {
162 return Ok(false);
163 }
164
165 jvm.invoke_special(
166 &this,
167 "java/util/logging/Handler",
168 "isLoggable",
169 "(Ljava/util/logging/LogRecord;)Z",
170 (record,),
171 )
172 .await
173 }
174
175 async fn publish(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<()> {
176 tracing::debug!("java.util.logging.StreamHandler::publish({this:?}, {record:?})");
177
178 let loggable: bool = jvm
179 .invoke_virtual(
180 &this,
181 "java/util/logging/StreamHandler",
182 "isLoggable",
183 "(Ljava/util/logging/LogRecord;)Z",
184 (record.clone(),),
185 )
186 .await?;
187 if !loggable {
188 return Ok(());
189 }
190
191 if let Err(JavaError::JavaException(exception)) = Self::write_head(jvm, &this).await {
192 if !jvm.is_instance(&*exception, "java/lang/Exception") {
193 return Err(JavaError::JavaException(exception));
194 }
195 let message: ClassInstanceRef<String> = None.into();
196 let exception: ClassInstanceRef<Exception> = exception.into();
197 let _: () = jvm
198 .invoke_virtual(
199 &this,
200 "java/util/logging/StreamHandler",
201 "reportError",
202 "(Ljava/lang/String;Ljava/lang/Exception;I)V",
203 (message, exception, 1),
204 )
205 .await?;
206 return Ok(());
207 }
208 let formatter: ClassInstanceRef<Formatter> = jvm.get_field(&this, "formatter", "Ljava/util/logging/Formatter;").await?;
209 let formatted: ClassInstanceRef<String> = match jvm
210 .invoke_virtual(
211 &formatter,
212 "java/util/logging/Formatter",
213 "format",
214 "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
215 (record,),
216 )
217 .await
218 {
219 Ok(formatted) => formatted,
220 Err(JavaError::JavaException(exception)) => {
221 if !jvm.is_instance(&*exception, "java/lang/Exception") {
222 return Err(JavaError::JavaException(exception));
223 }
224 let message: ClassInstanceRef<String> = None.into();
225 let exception: ClassInstanceRef<Exception> = exception.into();
226 let _: () = jvm
227 .invoke_virtual(
228 &this,
229 "java/util/logging/StreamHandler",
230 "reportError",
231 "(Ljava/lang/String;Ljava/lang/Exception;I)V",
232 (message, exception, 5),
233 )
234 .await?;
235 return Ok(());
236 }
237 };
238 let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
239 if let Err(JavaError::JavaException(exception)) = jvm
240 .invoke_virtual::<_, ()>(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (formatted,))
241 .await
242 {
243 if !jvm.is_instance(&*exception, "java/lang/Exception") {
244 return Err(JavaError::JavaException(exception));
245 }
246 let message: ClassInstanceRef<String> = None.into();
247 let exception: ClassInstanceRef<Exception> = exception.into();
248 let _: () = jvm
249 .invoke_virtual(
250 &this,
251 "java/util/logging/StreamHandler",
252 "reportError",
253 "(Ljava/lang/String;Ljava/lang/Exception;I)V",
254 (message, exception, 1),
255 )
256 .await?;
257 }
258 Ok(())
259 }
260
261 async fn set_encoding(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, encoding: ClassInstanceRef<String>) -> Result<()> {
262 tracing::debug!("java.util.logging.StreamHandler::setEncoding({this:?}, {encoding:?})");
263
264 let _: () = jvm
265 .invoke_special(
266 &this,
267 "java/util/logging/Handler",
268 "setEncoding",
269 "(Ljava/lang/String;)V",
270 (encoding.clone(),),
271 )
272 .await?;
273
274 let output: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "output", "Ljava/io/OutputStream;").await?;
275 if output.is_null() {
276 return Ok(());
277 }
278
279 let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
280 let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
281 let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
282 jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output,))
283 .await?
284 .into()
285 } else {
286 jvm.new_class(
287 "java/io/OutputStreamWriter",
288 "(Ljava/io/OutputStream;Ljava/lang/String;)V",
289 (output, encoding),
290 )
291 .await?
292 .into()
293 };
294 jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await
295 }
296
297 async fn set_output_stream(
298 jvm: &Jvm,
299 _: &mut RuntimeContext,
300 mut this: ClassInstanceRef<Self>,
301 output: ClassInstanceRef<OutputStream>,
302 ) -> Result<()> {
303 tracing::debug!("java.util.logging.StreamHandler::setOutputStream({this:?}, {output:?})");
304
305 if output.is_null() {
306 return Err(jvm.exception("java/lang/NullPointerException", "output").await);
307 }
308
309 let current_writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
310 if !current_writer.is_null() {
311 Self::write_tail(jvm, &this).await?;
312 let _: () = jvm
313 .invoke_virtual(¤t_writer, "java/io/OutputStreamWriter", "flush", "()V", ())
314 .await?;
315 let _: () = jvm
316 .invoke_virtual(¤t_writer, "java/io/OutputStreamWriter", "close", "()V", ())
317 .await?;
318 }
319
320 let encoding: ClassInstanceRef<String> = jvm.get_field(&this, "encoding", "Ljava/lang/String;").await?;
321 let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
322 jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output.clone(),))
323 .await?
324 .into()
325 } else {
326 jvm.new_class(
327 "java/io/OutputStreamWriter",
328 "(Ljava/io/OutputStream;Ljava/lang/String;)V",
329 (output.clone(), encoding),
330 )
331 .await?
332 .into()
333 };
334 jvm.put_field(&mut this, "output", "Ljava/io/OutputStream;", output).await?;
335 jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await?;
336 jvm.put_field(&mut this, "headerWritten", "Z", false).await
337 }
338
339 async fn write_head(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
340 if jvm.get_field::<bool>(this, "headerWritten", "Z").await? {
341 return Ok(());
342 }
343
344 let formatter: ClassInstanceRef<Formatter> = jvm.get_field(this, "formatter", "Ljava/util/logging/Formatter;").await?;
345 let head: ClassInstanceRef<String> = jvm
346 .invoke_virtual(
347 &formatter,
348 "java/util/logging/Formatter",
349 "getHead",
350 "(Ljava/util/logging/Handler;)Ljava/lang/String;",
351 (this.clone(),),
352 )
353 .await?;
354 let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "writer", "Ljava/io/OutputStreamWriter;").await?;
355 let _: () = jvm
356 .invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (head,))
357 .await?;
358 let mut this = this.clone();
359 jvm.put_field(&mut this, "headerWritten", "Z", true).await
360 }
361
362 async fn write_tail(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
363 Self::write_head(jvm, this).await?;
364 let formatter: ClassInstanceRef<Formatter> = jvm.get_field(this, "formatter", "Ljava/util/logging/Formatter;").await?;
365 let tail: ClassInstanceRef<String> = jvm
366 .invoke_virtual(
367 &formatter,
368 "java/util/logging/Formatter",
369 "getTail",
370 "(Ljava/util/logging/Handler;)Ljava/lang/String;",
371 (this.clone(),),
372 )
373 .await?;
374 let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "writer", "Ljava/io/OutputStreamWriter;").await?;
375 jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (tail,))
376 .await
377 }
378}