implements PLN-0150

This commit is contained in:
2026-07-04 19:36:24 +01:00
parent c3d6b70b0c
commit fa2e329d4b
6 changed files with 116 additions and 17 deletions
@@ -230,7 +230,12 @@ impl Firmware {
return None;
}
let app_id = self.os.vm().current_app_id();
let app_id = self
.os
.sessions()
.vm_session_for_task(task_id)
.map(|session| session.app_id)
.unwrap_or_else(|| self.os.vm().current_app_id());
self.os.vm().transition_render_owner(AppMode::Game, app_id);
self.game_input_barrier_frames = self.game_input_barrier_frames.max(1);
Some(FirmwareState::GameRunning(GameRunningStep::new(task_id)))
@@ -40,13 +40,19 @@ impl HubHomeStep {
Some(SystemProfileAction::LaunchGame { path }) => match CartridgeLoader::load(&path) {
Ok(cartridge) => {
if cartridge.app_mode == AppMode::Game
&& ctx.os.lifecycle().resident_game_task().is_some()
&& let Some(resident_task_id) = ctx.os.lifecycle().resident_game_task()
{
if ctx.os.vm().current_app_id() == cartridge.app_id {
let resident_app_id = ctx
.os
.sessions()
.vm_session_for_task(resident_task_id)
.map(|session| session.app_id)
.unwrap_or(0);
if resident_app_id == cartridge.app_id {
return Some(FirmwareState::ResumeResidentGame);
}
let resident_app_id = ctx.os.vm().current_app_id();
ctx.os.log(
LogLevel::Warn,
LogSource::Hub,
@@ -14,11 +14,13 @@ use prometeu_system::windows::WindowOwner;
pub struct LoadCartridgeStep {
pub cartridge: Cartridge,
init_error: Option<CrashReport>,
loaded_task_id: Option<prometeu_system::task::TaskId>,
loaded_app_mode: Option<AppMode>,
}
impl LoadCartridgeStep {
pub fn new(cartridge: Cartridge) -> Self {
Self { cartridge, init_error: None }
Self { cartridge, init_error: None, loaded_task_id: None, loaded_app_mode: None }
}
pub fn on_enter(&mut self, ctx: &mut PrometeuContext) {
@@ -36,7 +38,15 @@ impl LoadCartridgeStep {
self.cartridge.assets.clone(),
);
self.init_error = ctx.os.vm().initialize(ctx.vm, &self.cartridge).err();
match ctx.os.sessions().load_vm_cartridge(ctx.vm, &self.cartridge) {
Ok(loaded) => {
self.loaded_task_id = Some(loaded.task_id);
self.loaded_app_mode = Some(loaded.app_mode);
}
Err(report) => {
self.init_error = Some(report);
}
}
}
pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
@@ -44,11 +54,18 @@ impl LoadCartridgeStep {
return Some(FirmwareState::AppCrashes(AppCrashesStep { report }));
}
if self.cartridge.app_mode == AppMode::Shell {
let task_id = ctx
.os
.sessions()
.create_vm_shell_task(self.cartridge.app_id, self.cartridge.title.clone());
let Some(task_id) = self.loaded_task_id.take() else {
let report = CrashReport::VmPanic {
message: format!(
"cartridge {} was not loaded into a VM session",
self.cartridge.title
),
pc: None,
};
return Some(FirmwareState::AppCrashes(AppCrashesStep { report }));
};
if self.loaded_app_mode == Some(AppMode::Shell) {
let id = ctx.os.windows().add_window(
self.cartridge.title.clone(),
WindowOwner::Task(task_id),
@@ -59,10 +76,6 @@ impl LoadCartridgeStep {
return Some(FirmwareState::ShellRunning(ShellRunningStep::new(task_id)));
}
let task_id = ctx
.os
.sessions()
.create_vm_game_task(self.cartridge.app_id, self.cartridge.title.clone());
Some(FirmwareState::GameRunning(GameRunningStep::new(task_id)))
}
@@ -1,9 +1,20 @@
use crate::CrashReport;
use crate::os::LifecycleError;
use crate::os::SystemOS;
use crate::task::TaskId;
use crate::vm_session::{VmSession, VmSessionError};
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::cartridge::Cartridge;
use prometeu_vm::VirtualMachine;
use std::sync::Arc;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LoadedVmCartridge {
pub task_id: TaskId,
pub app_mode: AppMode,
pub reused_existing_session: bool,
}
pub struct SessionsFacade<'a> {
pub(in crate::os) os: &'a mut SystemOS,
}
@@ -59,6 +70,42 @@ impl<'a> SessionsFacade<'a> {
task_id
}
pub fn load_vm_cartridge(
&mut self,
legacy_vm: &mut VirtualMachine,
cartridge: &Cartridge,
) -> Result<LoadedVmCartridge, CrashReport> {
let existing_game_task = if cartridge.app_mode == AppMode::Game {
self.os
.vm_sessions
.resident_game_for_app(cartridge.app_id)
.map(|session| session.task_id)
} else {
None
};
let (task_id, reused_existing_session) = if let Some(task_id) = existing_game_task {
(task_id, true)
} else if cartridge.app_mode == AppMode::Shell {
(self.create_vm_shell_task(cartridge.app_id, cartridge.title.clone()), false)
} else {
let task_id = self
.try_create_vm_game_task(cartridge.app_id, cartridge.title.clone())
.map_err(|error| CrashReport::VmPanic {
message: format!("failed to create VM game task: {error:?}"),
pc: None,
})?;
(task_id, false)
};
if !reused_existing_session {
self.initialize_session_cartridge(task_id, cartridge)?;
self.initialize_legacy_active_vm(legacy_vm, cartridge)?;
}
Ok(LoadedVmCartridge { task_id, app_mode: cartridge.app_mode, reused_existing_session })
}
pub fn vm_session_for_task(&self, task_id: TaskId) -> Option<&VmSession> {
self.os.vm_sessions.for_task(task_id)
}
@@ -91,4 +138,32 @@ impl<'a> SessionsFacade<'a> {
.create_for_task(&task, &process, "", Some(cap_config), logs_count)
.map(|_| ())
}
fn initialize_session_cartridge(
&mut self,
task_id: TaskId,
cartridge: &Cartridge,
) -> Result<(), CrashReport> {
let session = self
.os
.vm_sessions
.for_task_mut(task_id)
.expect("loaded VM task should have a VM session");
session.app_id = cartridge.app_id;
session.title = cartridge.title.clone();
session.app_version = cartridge.app_version.clone();
session.app_mode = cartridge.app_mode;
session.clear_cartridge_service_state();
session.runtime.initialize_vm(&mut self.os.log_service, &mut session.vm, cartridge)
}
fn initialize_legacy_active_vm(
&mut self,
legacy_vm: &mut VirtualMachine,
cartridge: &Cartridge,
) -> Result<(), CrashReport> {
self.os.clear_cartridge_service_state();
self.os.vm_runtime.initialize_vm(&mut self.os.log_service, legacy_vm, cartridge)
}
}