use alloc::vec;
use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::{
RuntimeClassProto, RuntimeContext,
classes::java::util::{TimerTask, TimerTaskQueue},
};
enum WorkerAction {
Continue,
Run(ClassInstanceRef<TimerTask>),
Stop,
}
pub struct TimerThread;
impl TimerThread {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/util/Timer$TimerThread",
parent_class: Some("java/lang/Thread"),
interfaces: vec![],
methods: vec![
JavaMethodProto::new("<init>", "(Ljava/util/Timer$TaskQueue;)V", Self::init, MethodAccessFlags::empty()),
JavaMethodProto::new("run", "()V", Self::run, MethodAccessFlags::PUBLIC),
],
fields: vec![
JavaFieldProto::new("queue", "Ljava/util/Timer$TaskQueue;", FieldAccessFlags::PRIVATE),
JavaFieldProto::new("newTasksMayBeScheduled", "Z", FieldAccessFlags::empty()),
],
access_flags: ClassAccessFlags::empty(),
}
}
async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, queue: ClassInstanceRef<TimerTaskQueue>) -> Result<()> {
tracing::debug!("java.util.Timer$TimerThread::<init>({this:?})");
let _: () = jvm.invoke_special(&this, "java/lang/Thread", "<init>", "()V", ()).await?;
jvm.put_field(&mut this, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;", queue)
.await?;
jvm.put_field(&mut this, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z", true)
.await?;
Ok(())
}
async fn run(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.util.Timer$TimerThread::run({this:?})");
let result = Self::main_loop(jvm, context, &this).await;
let mut thread = this;
let mut queue: ClassInstanceRef<TimerTaskQueue> = jvm
.get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;")
.await?;
jvm.monitor_enter(&queue).await?;
let cleanup_result = async {
jvm.put_field(&mut thread, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z", false)
.await?;
TimerTaskQueue::clear(jvm, &mut queue).await?;
jvm.object_notify(&queue, usize::MAX).await
}
.await;
let exit_result = jvm.monitor_exit(&queue).await;
match result {
Ok(()) => {
cleanup_result?;
exit_result
}
Err(error) => {
if let Err(cleanup_error) = cleanup_result {
exit_result?;
return Err(cleanup_error);
}
exit_result?;
Err(error)
}
}
}
async fn main_loop(jvm: &Jvm, context: &mut RuntimeContext, this: &ClassInstanceRef<Self>) -> Result<()> {
let mut queue: ClassInstanceRef<TimerTaskQueue> = jvm
.get_field(this, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;")
.await?;
loop {
jvm.monitor_enter(&queue).await?;
let action_result = async {
loop {
let size: i32 = jvm.get_field(&queue, "java/util/Timer$TaskQueue", "size", "I").await?;
if size == 0 {
if !jvm
.get_field::<bool>(this, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z")
.await?
{
return Ok(WorkerAction::Stop);
}
let wait_result: Result<()> = jvm.invoke_virtual(&queue, "java/lang/Object", "wait", "()V", ()).await;
if let Err(error) = wait_result
&& !matches!(
&error,
JavaError::JavaException(exception)
if exception.class_definition().name() == "java/lang/InterruptedException"
)
{
return Err(error);
}
continue;
}
let heap: ClassInstanceRef<Array<TimerTask>> = jvm
.get_field(&queue, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;")
.await?;
let mut task: ClassInstanceRef<TimerTask> = jvm.load_array(&heap, 1, 1).await?.remove(0);
let lock: ClassInstanceRef<crate::classes::java::lang::Object> =
jvm.get_field(&task, "java/util/TimerTask", "lock", "Ljava/lang/Object;").await?;
jvm.monitor_enter(&lock).await?;
let task_result = async {
let state: i32 = jvm.get_field(&task, "java/util/TimerTask", "state", "I").await?;
if state == TimerTask::CANCELLED {
TimerTaskQueue::remove_min(jvm, &mut queue).await?;
return Ok(WorkerAction::Continue);
}
let now = context.now() as i64;
let execution_time: i64 = jvm.get_field(&task, "java/util/TimerTask", "nextExecutionTime", "J").await?;
if execution_time > now {
return Ok(WorkerAction::Continue);
}
let period: i64 = jvm.get_field(&task, "java/util/TimerTask", "period", "J").await?;
jvm.put_field(&mut task, "java/util/TimerTask", "lastScheduledExecutionTime", "J", execution_time)
.await?;
if period == 0 {
TimerTaskQueue::remove_min(jvm, &mut queue).await?;
jvm.put_field(&mut task, "java/util/TimerTask", "state", "I", TimerTask::EXECUTED).await?;
} else {
let next_execution_time = if period < 0 {
now.checked_sub(period)
} else {
execution_time.checked_add(period)
};
if let Some(next_execution_time) = next_execution_time {
TimerTaskQueue::reschedule_min(jvm, &mut queue, next_execution_time).await?;
} else {
TimerTaskQueue::remove_min(jvm, &mut queue).await?;
jvm.put_field(&mut task, "java/util/TimerTask", "state", "I", TimerTask::EXECUTED).await?;
}
}
Ok(WorkerAction::Run(task.clone()))
}
.await;
let task_exit_result = jvm.monitor_exit(&lock).await;
let action = match task_result {
Ok(action) => {
task_exit_result?;
action
}
Err(error) => {
task_exit_result?;
return Err(error);
}
};
if matches!(action, WorkerAction::Run(_)) {
return Ok(action);
}
let next_size: i32 = jvm.get_field(&queue, "java/util/Timer$TaskQueue", "size", "I").await?;
if next_size == 0 {
continue;
}
let next_heap: ClassInstanceRef<Array<TimerTask>> = jvm
.get_field(&queue, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;")
.await?;
let next_task: ClassInstanceRef<TimerTask> = jvm.load_array(&next_heap, 1, 1).await?.remove(0);
let next_execution_time: i64 = jvm.get_field(&next_task, "java/util/TimerTask", "nextExecutionTime", "J").await?;
let now = context.now() as i64;
if next_execution_time <= now {
continue;
}
let wait_result: Result<()> = jvm
.invoke_virtual(&queue, "java/lang/Object", "wait", "(J)V", (next_execution_time - now,))
.await;
if let Err(error) = wait_result
&& !matches!(
&error,
JavaError::JavaException(exception)
if exception.class_definition().name() == "java/lang/InterruptedException"
)
{
return Err(error);
}
}
}
.await;
let queue_exit_result = jvm.monitor_exit(&queue).await;
let action = match action_result {
Ok(action) => {
queue_exit_result?;
action
}
Err(error) => {
queue_exit_result?;
return Err(error);
}
};
match action {
WorkerAction::Continue => {}
WorkerAction::Run(task) => {
let _: () = jvm.invoke_virtual(&task, "java/util/TimerTask", "run", "()V", ()).await?;
}
WorkerAction::Stop => return Ok(()),
}
}
}
}