1use alloc::vec;
2
3use jvm::{ClassInstanceRef, 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::OutputStreamWriter,
11 lang::{Exception, String},
12 },
13};
14
15use super::{Filter, Formatter, Level, LogRecord};
16
17pub struct Handler;
19
20impl Handler {
21 pub fn as_proto() -> RuntimeClassProto {
22 RuntimeClassProto {
23 name: "java/util/logging/Handler",
24 parent_class: Some("java/lang/Object"),
25 interfaces: vec![],
26 methods: vec![
27 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
28 JavaMethodProto::new_abstract("close", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
29 JavaMethodProto::new_abstract("flush", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
30 JavaMethodProto::new_abstract(
31 "publish",
32 "(Ljava/util/logging/LogRecord;)V",
33 MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
34 ),
35 JavaMethodProto::new("getEncoding", "()Ljava/lang/String;", Self::get_encoding, MethodAccessFlags::PUBLIC),
36 JavaMethodProto::new("getFilter", "()Ljava/util/logging/Filter;", Self::get_filter, MethodAccessFlags::PUBLIC),
37 JavaMethodProto::new(
38 "getFormatter",
39 "()Ljava/util/logging/Formatter;",
40 Self::get_formatter,
41 MethodAccessFlags::PUBLIC,
42 ),
43 JavaMethodProto::new("getLevel", "()Ljava/util/logging/Level;", Self::get_level, MethodAccessFlags::PUBLIC),
44 JavaMethodProto::new(
45 "isLoggable",
46 "(Ljava/util/logging/LogRecord;)Z",
47 Self::is_loggable,
48 MethodAccessFlags::PUBLIC,
49 ),
50 JavaMethodProto::new(
51 "reportError",
52 "(Ljava/lang/String;Ljava/lang/Exception;I)V",
53 Self::report_error,
54 MethodAccessFlags::PROTECTED,
55 ),
56 JavaMethodProto::new("setEncoding", "(Ljava/lang/String;)V", Self::set_encoding, MethodAccessFlags::PUBLIC),
57 JavaMethodProto::new("setFilter", "(Ljava/util/logging/Filter;)V", Self::set_filter, MethodAccessFlags::PUBLIC),
58 JavaMethodProto::new(
59 "setFormatter",
60 "(Ljava/util/logging/Formatter;)V",
61 Self::set_formatter,
62 MethodAccessFlags::PUBLIC,
63 ),
64 JavaMethodProto::new("setLevel", "(Ljava/util/logging/Level;)V", Self::set_level, MethodAccessFlags::PUBLIC),
65 ],
66 fields: vec![
67 JavaFieldProto::new("level", "Ljava/util/logging/Level;", FieldAccessFlags::PRIVATE),
68 JavaFieldProto::new("filter", "Ljava/util/logging/Filter;", FieldAccessFlags::PRIVATE),
69 JavaFieldProto::new("formatter", "Ljava/util/logging/Formatter;", FieldAccessFlags::PRIVATE),
70 JavaFieldProto::new("encoding", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
71 ],
72 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
73 }
74 }
75
76 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
77 tracing::debug!("java.util.logging.Handler::<init>({this:?})");
78
79 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
80 let level: ClassInstanceRef<Level> = jvm
81 .get_static_field("java/util/logging/Level", "ALL", "Ljava/util/logging/Level;")
82 .await?;
83 jvm.put_field(&mut this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;", level)
84 .await
85 }
86
87 async fn get_encoding(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
88 tracing::debug!("java.util.logging.Handler::getEncoding({this:?})");
89
90 jvm.get_field(&this, "java/util/logging/Handler", "encoding", "Ljava/lang/String;").await
91 }
92
93 async fn get_filter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Filter>> {
94 tracing::debug!("java.util.logging.Handler::getFilter({this:?})");
95
96 jvm.get_field(&this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;")
97 .await
98 }
99
100 async fn get_formatter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Formatter>> {
101 tracing::debug!("java.util.logging.Handler::getFormatter({this:?})");
102
103 jvm.get_field(&this, "java/util/logging/Handler", "formatter", "Ljava/util/logging/Formatter;")
104 .await
105 }
106
107 async fn get_level(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Level>> {
108 tracing::debug!("java.util.logging.Handler::getLevel({this:?})");
109
110 jvm.get_field(&this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;")
111 .await
112 }
113
114 async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<bool> {
115 tracing::debug!("java.util.logging.Handler::isLoggable({this:?}, {record:?})");
116
117 if record.is_null() {
118 return Ok(false);
119 }
120
121 let record_level: ClassInstanceRef<Level> = jvm
122 .invoke_virtual(&record, "java/util/logging/LogRecord", "getLevel", "()Ljava/util/logging/Level;", ())
123 .await?;
124 let handler_level: ClassInstanceRef<Level> = jvm
125 .get_field(&this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;")
126 .await?;
127 let record_value: i32 = jvm
128 .invoke_virtual(&record_level, "java/util/logging/Level", "intValue", "()I", ())
129 .await?;
130 let handler_value: i32 = jvm
131 .invoke_virtual(&handler_level, "java/util/logging/Level", "intValue", "()I", ())
132 .await?;
133 if handler_value == i32::MAX || record_value < handler_value {
134 return Ok(false);
135 }
136
137 let filter: ClassInstanceRef<Filter> = jvm
138 .get_field(&this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;")
139 .await?;
140 if filter.is_null() {
141 return Ok(true);
142 }
143
144 jvm.invoke_virtual(
145 &filter,
146 &filter.class_definition().name(),
147 "isLoggable",
148 "(Ljava/util/logging/LogRecord;)Z",
149 (record,),
150 )
151 .await
152 }
153
154 async fn report_error(
155 _: &Jvm,
156 _: &mut RuntimeContext,
157 this: ClassInstanceRef<Self>,
158 _: ClassInstanceRef<String>,
159 _: ClassInstanceRef<Exception>,
160 _: i32,
161 ) -> Result<()> {
162 tracing::debug!("java.util.logging.Handler::reportError({this:?})");
163
164 Ok(())
165 }
166
167 async fn set_encoding(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, encoding: ClassInstanceRef<String>) -> Result<()> {
168 tracing::debug!("java.util.logging.Handler::setEncoding({this:?}, {encoding:?})");
169
170 if !encoding.is_null() {
171 OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
172 }
173 jvm.put_field(&mut this, "java/util/logging/Handler", "encoding", "Ljava/lang/String;", encoding)
174 .await
175 }
176
177 async fn set_filter(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, filter: ClassInstanceRef<Filter>) -> Result<()> {
178 tracing::debug!("java.util.logging.Handler::setFilter({this:?}, {filter:?})");
179
180 jvm.put_field(&mut this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;", filter)
181 .await
182 }
183
184 async fn set_formatter(
185 jvm: &Jvm,
186 _: &mut RuntimeContext,
187 mut this: ClassInstanceRef<Self>,
188 formatter: ClassInstanceRef<Formatter>,
189 ) -> Result<()> {
190 tracing::debug!("java.util.logging.Handler::setFormatter({this:?}, {formatter:?})");
191
192 if formatter.is_null() {
193 return Err(jvm.exception("java/lang/NullPointerException", "formatter").await);
194 }
195 jvm.put_field(
196 &mut this,
197 "java/util/logging/Handler",
198 "formatter",
199 "Ljava/util/logging/Formatter;",
200 formatter,
201 )
202 .await
203 }
204
205 async fn set_level(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, level: ClassInstanceRef<Level>) -> Result<()> {
206 tracing::debug!("java.util.logging.Handler::setLevel({this:?}, {level:?})");
207
208 if level.is_null() {
209 return Err(jvm.exception("java/lang/NullPointerException", "level").await);
210 }
211 jvm.put_field(&mut this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;", level)
212 .await
213 }
214}