use alloc::{string::String as RustString, vec, vec::Vec};
use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::{
RuntimeClassProto, RuntimeContext,
classes::java::{
lang::{Object, String},
util::{
Hashtable,
logging::{ConsoleHandler, Handler, Level, Logger},
},
},
};
pub struct LogManager;
impl LogManager {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/util/logging/LogManager",
parent_class: Some("java/lang/Object"),
interfaces: vec![],
methods: vec![
JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
JavaMethodProto::new(
"getLogManager",
"()Ljava/util/logging/LogManager;",
Self::get_log_manager,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new("addLogger", "(Ljava/util/logging/Logger;)Z", Self::add_logger, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"registerLogger",
"(Ljava/lang/String;Ljava/util/logging/Logger;)Z",
Self::register_logger,
MethodAccessFlags::PRIVATE | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"getLogger",
"(Ljava/lang/String;)Ljava/util/logging/Logger;",
Self::get_logger,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"getLoggerNames",
"()Ljava/util/Enumeration;",
Self::get_logger_names,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"snapshotLoggers",
"()[Ljava/util/logging/Logger;",
Self::snapshot_loggers,
MethodAccessFlags::PRIVATE | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("checkAccess", "()V", Self::check_access, MethodAccessFlags::PUBLIC),
],
fields: vec![
JavaFieldProto::new(
"manager",
"Ljava/util/logging/LogManager;",
FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC,
),
JavaFieldProto::new("loggers", "Ljava/util/Hashtable;", FieldAccessFlags::PRIVATE),
JavaFieldProto::new("root", "Ljava/util/logging/Logger;", FieldAccessFlags::PRIVATE),
],
access_flags: ClassAccessFlags::PUBLIC,
}
}
async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
tracing::debug!("java.util.logging.LogManager::<clinit>()");
let manager = jvm.new_class("java/util/logging/LogManager", "()V", ()).await?;
jvm.put_static_field("java/util/logging/LogManager", "manager", "Ljava/util/logging/LogManager;", manager)
.await
}
async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.util.logging.LogManager::<init>({this:?})");
let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
let loggers: ClassInstanceRef<Hashtable> = jvm.new_class("java/util/Hashtable", "()V", ()).await?.into();
jvm.put_field(
&mut this,
"java/util/logging/LogManager",
"loggers",
"Ljava/util/Hashtable;",
loggers.clone(),
)
.await?;
let root_name = JavaLangString::from_rust_string(jvm, "").await?;
let resource_bundle_name: ClassInstanceRef<String> = None.into();
let mut root: ClassInstanceRef<Logger> = jvm
.new_class(
"java/util/logging/Logger",
"(Ljava/lang/String;Ljava/lang/String;)V",
(root_name.clone(), resource_bundle_name),
)
.await?
.into();
let info: ClassInstanceRef<Level> = jvm
.get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
.await?;
jvm.put_field(&mut root, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;", info)
.await?;
jvm.put_field(&mut root, "java/util/logging/Logger", "useParentHandlers", "Z", false)
.await?;
let console: ClassInstanceRef<ConsoleHandler> = jvm.new_class("java/util/logging/ConsoleHandler", "()V", ()).await?.into();
let _: () = jvm
.invoke_virtual(
&root,
"java/util/logging/Logger",
"addHandler",
"(Ljava/util/logging/Handler;)V",
(console,),
)
.await?;
let _: ClassInstanceRef<Object> = jvm
.invoke_virtual(
&loggers,
"java/util/Hashtable",
"put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
(root_name, root.clone()),
)
.await?;
jvm.put_field(
&mut this,
"java/util/logging/LogManager",
"root",
"Ljava/util/logging/Logger;",
root.clone(),
)
.await?;
let global_name: ClassInstanceRef<String> = jvm
.get_static_field("java/util/logging/Logger", "GLOBAL_LOGGER_NAME", "Ljava/lang/String;")
.await?;
let mut global: ClassInstanceRef<Logger> = jvm
.get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;")
.await?;
jvm.put_field(&mut global, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", root)
.await?;
let _: ClassInstanceRef<Object> = jvm
.invoke_virtual(
&loggers,
"java/util/Hashtable",
"put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
(global_name, global),
)
.await?;
Ok(())
}
async fn get_log_manager(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
tracing::debug!("java.util.logging.LogManager::getLogManager()");
jvm.get_static_field("java/util/logging/LogManager", "manager", "Ljava/util/logging/LogManager;")
.await
}
async fn add_logger(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, logger: ClassInstanceRef<Logger>) -> Result<bool> {
tracing::debug!("java.util.logging.LogManager::addLogger({this:?}, {logger:?})");
if logger.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "logger").await);
}
let name: ClassInstanceRef<String> = jvm
.invoke_virtual(&logger, "java/util/logging/Logger", "getName", "()Ljava/lang/String;", ())
.await?;
if name.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "logger name").await);
}
jvm.invoke_special(
&this,
"java/util/logging/LogManager",
"registerLogger",
"(Ljava/lang/String;Ljava/util/logging/Logger;)Z",
(name, logger),
)
.await
}
async fn register_logger(
jvm: &Jvm,
_: &mut RuntimeContext,
this: ClassInstanceRef<Self>,
name: ClassInstanceRef<String>,
logger: ClassInstanceRef<Logger>,
) -> Result<bool> {
let loggers: ClassInstanceRef<Hashtable> = jvm
.get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
.await?;
let existing: ClassInstanceRef<Object> = jvm
.invoke_virtual(
&loggers,
"java/util/Hashtable",
"get",
"(Ljava/lang/Object;)Ljava/lang/Object;",
(name.clone(),),
)
.await?;
if !existing.is_null() {
return Ok(false);
}
let _: ClassInstanceRef<Object> = jvm
.invoke_virtual(
&loggers,
"java/util/Hashtable",
"put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
(name, logger),
)
.await?;
Self::reconnect_parents(jvm, &this, &loggers).await?;
Ok(true)
}
async fn get_logger(
jvm: &Jvm,
_: &mut RuntimeContext,
this: ClassInstanceRef<Self>,
name: ClassInstanceRef<String>,
) -> Result<ClassInstanceRef<Logger>> {
tracing::debug!("java.util.logging.LogManager::getLogger({this:?}, {name:?})");
if name.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "name").await);
}
let loggers: ClassInstanceRef<Hashtable> = jvm
.get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
.await?;
jvm.invoke_virtual(&loggers, "java/util/Hashtable", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (name,))
.await
}
async fn get_logger_names(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.logging.LogManager::getLoggerNames({this:?})");
let loggers: ClassInstanceRef<Hashtable> = jvm
.get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
.await?;
jvm.invoke_virtual(&loggers, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ())
.await
}
async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.util.logging.LogManager::reset({this:?})");
let loggers: ClassInstanceRef<Array<Logger>> = jvm
.invoke_special(
&this,
"java/util/logging/LogManager",
"snapshotLoggers",
"()[Ljava/util/logging/Logger;",
(),
)
.await?;
let root: ClassInstanceRef<Logger> = jvm
.get_field(&this, "java/util/logging/LogManager", "root", "Ljava/util/logging/Logger;")
.await?;
let length = jvm.array_length(&loggers).await?;
let loggers: Vec<ClassInstanceRef<Logger>> = jvm.load_array(&loggers, 0, length).await?;
for logger in loggers {
let handlers: ClassInstanceRef<Array<Handler>> = jvm
.invoke_special(
&logger,
"java/util/logging/Logger",
"reset",
"(Z)[Ljava/util/logging/Handler;",
(logger.identity() == root.identity(),),
)
.await?;
let length = jvm.array_length(&handlers).await?;
let handlers: Vec<ClassInstanceRef<Handler>> = jvm.load_array(&handlers, 0, length).await?;
for handler in handlers {
let _: () = jvm.invoke_virtual(&handler, "java/util/logging/Handler", "close", "()V", ()).await?;
}
}
Ok(())
}
async fn snapshot_loggers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Logger>>> {
let loggers: ClassInstanceRef<Hashtable> = jvm
.get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
.await?;
let values: ClassInstanceRef<Object> = jvm
.invoke_virtual(&loggers, "java/util/Hashtable", "elements", "()Ljava/util/Enumeration;", ())
.await?;
let mut snapshot: Vec<ClassInstanceRef<Logger>> = Vec::new();
while jvm
.invoke_virtual::<_, bool>(&values, &values.class_definition().name(), "hasMoreElements", "()Z", ())
.await?
{
snapshot.push(
jvm.invoke_virtual(&values, &values.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
.await?,
);
}
let mut result: ClassInstanceRef<Array<Logger>> = jvm.instantiate_array("Ljava/util/logging/Logger;", snapshot.len()).await?.into();
for (index, logger) in snapshot.into_iter().enumerate() {
jvm.store_array(&mut result, index, [logger]).await?;
}
Ok(result)
}
async fn check_access(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.util.logging.LogManager::checkAccess({this:?})");
Ok(())
}
async fn reconnect_parents(jvm: &Jvm, manager: &ClassInstanceRef<Self>, loggers: &ClassInstanceRef<Hashtable>) -> Result<()> {
let names: ClassInstanceRef<Object> = jvm
.invoke_virtual(loggers, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ())
.await?;
let mut keys = Vec::new();
while jvm
.invoke_virtual::<_, bool>(&names, &names.class_definition().name(), "hasMoreElements", "()Z", ())
.await?
{
keys.push(
jvm.invoke_virtual(&names, &names.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
.await?,
);
}
let root: ClassInstanceRef<Logger> = jvm
.get_field(manager, "java/util/logging/LogManager", "root", "Ljava/util/logging/Logger;")
.await?;
for key in keys {
let name: RustString = JavaLangString::to_rust_string(jvm, &key).await?;
if name.is_empty() {
continue;
}
let mut logger: ClassInstanceRef<Logger> = jvm
.invoke_virtual(loggers, "java/util/Hashtable", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (key,))
.await?;
let mut parent = root.clone();
let mut prefix = name.as_str();
while let Some(index) = prefix.rfind('.') {
prefix = &prefix[..index];
let candidate_name = JavaLangString::from_rust_string(jvm, prefix).await?;
let candidate: ClassInstanceRef<Logger> = jvm
.invoke_virtual(
loggers,
"java/util/Hashtable",
"get",
"(Ljava/lang/Object;)Ljava/lang/Object;",
(candidate_name,),
)
.await?;
if !candidate.is_null() {
parent = candidate;
break;
}
}
jvm.put_field(&mut logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", parent)
.await?;
}
Ok(())
}
}