xous-core/services/gam/src/main.rs
bunnie 6e0d025dea add "menu mode" option to the IMEF
in "menu mode" the predictive area functions as four menu
option keys instead of dynamic prediction updates.

this patch is mostly working but we need to figure out how to
force a redraw of the predction area when the app is raised,
because we get a stale image from the previous app on context
switch.
2022-06-17 12:40:44 +08:00

620 lines
35 KiB
Rust

#![cfg_attr(baremetal, no_main)]
#![cfg_attr(baremetal, no_std)]
mod api;
use api::*;
mod canvas;
use canvas::*;
mod tokens;
use tokens::*;
mod layouts;
use layouts::*;
mod contexts;
use contexts::*;
use graphics_server::*;
use xous_ipc::{Buffer, String};
use api::Opcode;
use xous::{msg_scalar_unpack, msg_blocking_scalar_unpack};
use gam::{MAIN_MENU_NAME, ROOTKEY_MODAL_NAME};
use log::info;
use std::collections::HashMap;
use num_traits::*;
use core::sync::atomic::{AtomicU32, Ordering};
/// This sets the initial app focus on boot
const INITIAL_APP_FOCUS: &'static str = gam::APP_NAME_SHELLCHAT;
static CB_TO_MAIN_CONN: AtomicU32 = AtomicU32::new(0);
fn imef_cb(s: String::<4000>) {
if CB_TO_MAIN_CONN.load(Ordering::Relaxed) != 0 {
let cb_to_main_conn = CB_TO_MAIN_CONN.load(Ordering::Relaxed);
let buf = xous_ipc::Buffer::into_buf(s).or(Err(xous::Error::InternalError)).unwrap();
buf.lend(cb_to_main_conn, Opcode::InputLine.to_u32().unwrap()).unwrap();
}
}
fn main () -> ! {
#[cfg(feature="ditherpunk")]
let stack_size = 1024 * 1024;
#[cfg(not(feature="ditherpunk"))]
let stack_size = 128 * 1024;
std::thread::Builder::new()
.stack_size(stack_size)
.spawn(wrapped_main)
.unwrap()
.join()
.unwrap()
}
fn wrapped_main() -> ! {
log_server::init_wait().unwrap();
log::set_max_level(log::LevelFilter::Info);
info!("my PID is {}", xous::process::id());
let xns = xous_names::XousNames::new().unwrap();
// unlimited connections allowed; this is a gateway server
let gam_sid = xns.register_name(api::SERVER_NAME_GAM, None).expect("can't register server");
CB_TO_MAIN_CONN.store(xous::connect(gam_sid).unwrap(), Ordering::Relaxed);
log::trace!("starting up...");
let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");
let gfx = graphics_server::Gfx::new(&xns).expect("can't connect to GFX");
let trng = trng::Trng::new(&xns).expect("can't connect to TRNG");
let mut context_mgr = ContextManager::new(&xns);
// a map of canvases accessable by Gid
let mut canvases: HashMap<Gid, Canvas> = HashMap::new();
let screensize = gfx.screen_size().expect("Couldn't get screen size");
// the status canvas is special -- there can only be one, and it is ultimately trusted
let status_canvas = Canvas::new(
Rectangle::new_coords(
0, 0, screensize.x,
gfx.glyph_height_hint(GlyphStyle::Cjk).expect("couldn't get glyph height") as i16 * 2),
255, &trng, None, crate::api::CanvasType::Status
).expect("couldn't create status canvas");
let status_cliprect = status_canvas.clip_rect();
status_canvas.set_onscreen(true);
status_canvas.set_drawable(true);
let status_gid = status_canvas.gid().gid();
canvases.insert(status_canvas.gid(), status_canvas);
recompute_canvases(&canvases);
// initialize the status bar -- this needs to start late, after the IMEF and most other things are initialized
// this used to be domiciled in the GAM, but we split it out because this started to pull too much functionality
// into the GAM and was causing circular crate conflicts with sub-functions that the status bar relies upon.
// we do a hack to try and push a GID to the status bar "securely": we introduce a race condition where we hope
// that the GAM is the first thing to talk to the status bar, and the first message is its GID to render on.
// generally should be OK, because during boot, all processes are trusted...
let status_conn = xns.request_connection_blocking("_Status bar GID receiver_").expect("couldn't connect to status bar GID receiver");
xous::send_message(status_conn,
xous::Message::new_scalar(0, // message type doesn't matter because there is only one message it should ever receive
status_gid[0] as usize, status_gid[1] as usize, status_gid[2] as usize, status_gid[3] as usize
)
).expect("couldn't set status GID");
// a random number we can use to identify ourselves between API calls
let gam_token = [trng.get_u32().unwrap(), trng.get_u32().unwrap(), trng.get_u32().unwrap(), trng.get_u32().unwrap()];
let mut powerdown_requested = false;
let mut last_time: u64 = ticktimer.elapsed_ms();
let mut did_test = false; // allow one go at the test pattern
log::trace!("entering main loop");
#[cfg(not(any(target_os = "none", target_os = "xous")))]
{
log::info!("********************************************************************************");
log::info!("USAGE:");
log::info!(" `Home` key to bring up menu; arrow keys to go up/down; `Home` to select again");
log::info!(" `F1`-`F4` to pick predictions; `F5` and `F6` generate test unicode characters");
log::info!(" Otherwise type in the GUI window; `help` for the current command list");
log::info!(" ^C in the console window (this window) to quit");
log::info!("********************************************************************************");
}
loop {
let mut msg = xous::receive_message(gam_sid).unwrap();
log::trace!("Message: {:?}", msg);
match FromPrimitive::from_usize(msg.body.id()) {
Some(Opcode::ClearCanvas) => {
msg_scalar_unpack!(msg, g0, g1, g2, g3, {
let gid = Gid::new([g0 as _, g1 as _, g2 as _, g3 as _]);
match canvases.get(&gid) {
Some(c) => {
let mut rect = c.clip_rect();
rect.style = DrawStyle {fill_color: Some(PixelColor::Light), stroke_color: None, stroke_width: 0,};
gfx.draw_rectangle(rect).expect("can't clear canvas");
},
None => info!("attempt to clear bogus canvas, ignored."),
}
});
}
Some(Opcode::GetCanvasBounds) => {
msg_blocking_scalar_unpack!(msg, g0, g1, g2, g3, {
let gid = Gid::new([g0 as _, g1 as _, g2 as _, g3 as _]);
match canvases.get(&gid) {
Some(c) => {
let mut rect = c.clip_rect();
rect.normalize(); // normalize to 0,0 coordinates
log::trace!("getcanvasbounds: {:?}", rect);
xous::return_scalar2(msg.sender,
rect.tl.into(),
rect.br.into(),
).expect("couldn't return canvas bounds");
},
None => info!("attempt to get bounds on bogus canvas gid {:?}, {:?} ignored.", gid, msg),
}
})
}
Some(Opcode::PowerDownRequest) => {
msg_blocking_scalar_unpack!(msg, _, _, _, _, {
powerdown_requested = true;
gfx.draw_sleepscreen().expect("couldn't draw sleep screen");
// a screen flush is part of the draw_sleepscreen abstraction
xous::return_scalar(msg.sender, 1).expect("couldn't confirm power down UI request");
})
}
Some(Opcode::ShipModeBlankRequest) => {
msg_blocking_scalar_unpack!(msg, _, _, _, _, {
powerdown_requested = true;
gfx.draw_rectangle(Rectangle::new_with_style(Point::new(0,0), screensize, DrawStyle::new(PixelColor::Light, PixelColor::Light, 0))).expect("couldn't clear screen");
gfx.flush().expect("couldn't refresh blank screen");
xous::return_scalar(msg.sender, 1).expect("couldn't confirm power down UI request");
})
}
Some(Opcode::Redraw) => {
msg_scalar_unpack!(msg, _, _, _, _, {
log::trace!("redraw message received");
if powerdown_requested {
continue; // don't allow any redraws if a powerdown is requested
}
let elapsed_time = ticktimer.elapsed_ms();
if elapsed_time - last_time > 33 { // rate limit updates, no point in going faster than the eye can see
last_time = elapsed_time;
if deface(&gfx, &trng, &mut canvases) {
// we keep this here because it's a fail-safe in case prior routines missed an edge case. shoot out a warning noting the issue.
log::warn!("canvases were not defaced in order. running a defacement, but this could result in drawing optimizations failing.");
// try to redraw the trusted foreground apps after a defacement
log::trace!("deface redraw");
context_mgr.redraw().expect("couldn't redraw after defacement");
}
log::trace!("flushing...");
gfx.flush().expect("couldn't flush buffer to screen");
for (_, c) in canvases.iter_mut() {
c.do_flushed().expect("couldn't update flushed state");
}
}
})
}
Some(Opcode::SetDebugLevel) => msg_blocking_scalar_unpack!(msg, level, _, _, _, {
match level {
0 => log::set_max_level(log::LevelFilter::Info),
1 => log::set_max_level(log::LevelFilter::Debug),
2 => log::set_max_level(log::LevelFilter::Trace),
_ => log::set_max_level(log::LevelFilter::Info),
}
xous::return_scalar(msg.sender, level).unwrap();
}),
Some(Opcode::RenderTextView) => {
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut tv = buffer.to_original::<TextView, _>().unwrap();
log::trace!("rendertextview {:?}", tv);
match tv.get_op() {
TextOp::Nop => (),
TextOp::Render => {
if tv.invert & tv.token.is_some() {
// an inverted text can only be made by secure processes. check that it has a valid token.
if !context_mgr.is_token_valid(tv.token.unwrap()) {
log::error!("Attempt to draw inverted text without valid credentials. Aborting.");
continue;
}
}
log::trace!("render request for {:?}", tv);
if let Some(canvas) = canvases.get_mut(&tv.get_canvas_gid()) {
tv.set_dry_run(!canvas.is_onscreen());
// if we're requesting inverted text, this better be a "trusted canvas"
// BOOT_CONTEXT_TRUSTLEVEL is reserved for the "status bar"
// BOOT_CONTEXT_TRUSTLEVEL - 1 is where e.g. password modal dialog boxes end up
if tv.invert & (canvas.trust_level() < BOOT_CONTEXT_TRUSTLEVEL - 1) {
log::error!("Attempt to draw inverted text without sufficient trust level: {}. Aborting.", canvas.trust_level());
continue;
}
// first, figure out if we should even be drawing to this canvas.
if canvas.is_drawable() {
// set the clip rectangle according to the canvas' location
let base_clip_rect = canvas.clip_rect();
tv.clip_rect = Some(base_clip_rect.into());
// you have to clone the tv object, because if you don't the same block of
// memory gets passed on to the graphics_server(). Which is efficient, but,
// the call will automatically Drop() the memory, which causes a panic when
// this routine returns.
let mut tv_clone = tv.clone();
// issue the draw command
gfx.draw_textview(&mut tv_clone).expect("text view draw could not complete.");
// copy back the fields that we want to be mutable
tv.cursor = tv_clone.cursor;
tv.bounds_computed = tv_clone.bounds_computed;
let ret = api::Return::RenderReturn(tv);
buffer.replace(ret).unwrap();
if canvas.is_onscreen() {
canvas.do_drawn().expect("couldn't set canvas to drawn");
}
} else {
log::debug!("attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored. {:?}", tv);
let ret = api::Return::NotCurrentlyDrawable;
buffer.replace(ret).unwrap();
}
} else {
info!("bogus GID {:?} in TextView {}, not doing anything in response to draw request.", tv.get_canvas_gid(), tv.text);
// silently fail if a bogus Gid is given???
}
},
TextOp::ComputeBounds => {
log::trace!("render request for {:?}", tv);
tv.set_dry_run(true);
if tv.clip_rect.is_none() {
// fill in the clip rect from the canvas
if let Some(canvas) = canvases.get_mut(&tv.get_canvas_gid()) {
// set the clip rectangle according to the canvas' location
let mut base_clip_rect = canvas.clip_rect();
base_clip_rect.normalize();
tv.clip_rect = Some(base_clip_rect.into());
} else {
info!("bogus GID {:?} in TextView {}, not doing anything in response to draw request.", tv.get_canvas_gid(), tv.text);
// silently fail if a bogus Gid is given???
continue;
}
}
let mut tv_clone = tv.clone();
// issue the draw command
gfx.draw_textview(&mut tv_clone).expect("text view draw could not complete.");
// copy back the fields that we want to be mutable
log::trace!("got computed cursor of {:?}, bounds {:?}", tv_clone.cursor, tv_clone.bounds_computed);
tv.cursor = tv_clone.cursor;
tv.bounds_computed = tv_clone.bounds_computed;
let ret = api::Return::RenderReturn(tv);
buffer.replace(ret).unwrap();
}
};
}
Some(Opcode::SetCanvasBounds) => {
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut cb = buffer.to_original::<SetCanvasBoundsRequest, _>().unwrap();
log::trace!("SetCanvasBoundsRequest {:?}", cb);
let granted = if cb.token_type == TokenType::Gam {
context_mgr.set_canvas_height(&gfx, cb.token, cb.requested.y, &status_cliprect, &mut canvases)
} else {
context_mgr.set_canvas_height_app_token(&gfx, cb.token, cb.requested.y, &status_cliprect, &mut canvases)
};
if granted.is_some() {
// recompute the canvas orders based on the new layout
recompute_canvases(&canvases);
// this set of redraw commands is not needed because every context will call redraw after it has finished fitting its bounds
// log::info!("canvas bounds redraw");
// context_mgr.redraw().expect("can't redraw after new canvas bounds");
}
cb.granted = granted;
let ret = api::Return::SetCanvasBoundsReturn(cb);
log::trace!("returning {:?}", cb);
buffer.replace(ret).unwrap();
}
Some(Opcode::RequestContentCanvas) => {
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let req = buffer.to_original::<[u32; 4], _>().unwrap();
log::trace!("RequestContentCanvas {:?}", req);
let ret = api::Return::ContentCanvasReturn(context_mgr.get_content_canvas(req));
buffer.replace(ret).unwrap();
}
#[cfg(feature="ditherpunk")]
Some(Opcode::RenderTile) => {
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let mut obj = buffer.to_original::<GamTile, _>().unwrap();
log::debug!("RenderTile {:?}", obj);
if let Some(canvas) = canvases.get_mut(&obj.canvas) {
// first, figure out if we should even be drawing to this canvas.
log::debug!("drawable {} onscreen {} state{:?} for canvas {:?}", canvas.is_drawable(), canvas.is_onscreen(), canvas.state(), canvas.gid());
if canvas.is_drawable() && canvas.is_onscreen() {
obj.tile.translate(canvas.clip_rect().tl);
obj.tile.translate(canvas.pan_offset());
log::trace!("drawing tile {:?}", obj.tile);
gfx.draw_tile_clipped(
obj.tile,
canvas.clip_rect(),
).expect("couldn't draw bitmap");
canvas.do_drawn().expect("couldn't set canvas to drawn");
} else {
log::info!("attempt to draw Object on non-drawable canvas. Not fatal, but request ignored: {:?}", obj);
}
} else {
info!("bogus GID in Object, not doing anything in response to draw request.");
}
log::trace!("leaving RenderTile");
}
Some(Opcode::RenderObject) => {
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let obj = buffer.to_original::<GamObject, _>().unwrap();
log::trace!("renderobject {:?}", obj);
if let Some(canvas) = canvases.get_mut(&obj.canvas) {
// first, figure out if we should even be drawing to this canvas.
log::debug!("drawable {} onscreen {} state{:?} for canvas {:?}", canvas.is_drawable(), canvas.is_onscreen(), canvas.state(), canvas.gid());
if canvas.is_drawable() && canvas.is_onscreen() {
match obj.obj {
GamObjectType::Line(mut line) => {
line.translate(canvas.clip_rect().tl);
line.translate(canvas.pan_offset());
gfx.draw_line_clipped(
line,
canvas.clip_rect(),
).expect("couldn't draw line");
},
GamObjectType::Circ(mut circ) => {
circ.translate(canvas.clip_rect().tl);
circ.translate(canvas.pan_offset());
gfx.draw_circle_clipped(
circ,
canvas.clip_rect(),
).expect("couldn't draw circle");
},
GamObjectType::Rect(mut rect) => {
rect.translate(canvas.clip_rect().tl);
rect.translate(canvas.pan_offset());
gfx.draw_rectangle_clipped(
rect,
canvas.clip_rect(),
).expect("couldn't draw rectangle");
},
GamObjectType::RoundRect(mut rr) => {
rr.translate(canvas.clip_rect().tl);
rr.translate(canvas.pan_offset());
gfx.draw_rounded_rectangle_clipped(
rr,
canvas.clip_rect(),
).expect("couldn't draw rounded rectangle");
}
}
canvas.do_drawn().expect("couldn't set canvas to drawn");
} else {
log::debug!("attempt to draw Object on non-drawable canvas. Not fatal, but request ignored: {:?}", obj);
}
} else {
info!("bogus GID in Object, not doing anything in response to draw request.");
}
log::trace!("leaving RenderObject");
}
Some(Opcode::RenderObjectList) => {
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let obj_ipc = buffer.to_original::<GamObjectList, _>().unwrap();
if let Some(canvas) = canvases.get_mut(&obj_ipc.canvas) {
// first, figure out if we should even be drawing to this canvas.
if canvas.is_drawable() && canvas.is_onscreen() {
let mut obj_list = ClipObjectList::default();
for item in obj_ipc.list.iter() {
if let Some(obj) = item {
match obj {
GamObjectType::Line(mut line) => {
line.translate(canvas.clip_rect().tl);
line.translate(canvas.pan_offset());
obj_list.push(ClipObjectType::Line(line), canvas.clip_rect()).unwrap();
},
GamObjectType::Circ(mut circ) => {
circ.translate(canvas.clip_rect().tl);
circ.translate(canvas.pan_offset());
obj_list.push(ClipObjectType::Circ(circ), canvas.clip_rect()).unwrap();
},
GamObjectType::Rect(mut rect) => {
rect.translate(canvas.clip_rect().tl);
rect.translate(canvas.pan_offset());
obj_list.push(ClipObjectType::Rect(rect), canvas.clip_rect()).unwrap();
},
GamObjectType::RoundRect(mut rr) => {
rr.translate(canvas.clip_rect().tl);
rr.translate(canvas.pan_offset());
obj_list.push(ClipObjectType::RoundRect(rr), canvas.clip_rect()).unwrap();
},
}
} else {
break;
}
}
gfx.draw_object_list_clipped(obj_list).expect("couldn't draw object list");
canvas.do_drawn().expect("couldn't set canvas to drawn");
} else {
log::debug!("attempt to draw Object on non-drawable canvas. Not fatal, but request ignored: {:?}", obj_ipc);
}
} else {
info!("bogus GID in Object, not doing anything in response to draw request.");
}
}
Some(Opcode::ClaimToken) => {
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut tokenclaim = buffer.to_original::<TokenClaim, _>().unwrap();
tokenclaim.token = context_mgr.claim_token(tokenclaim.name.as_str().unwrap());
buffer.replace(tokenclaim).unwrap();
},
Some(Opcode::TrustedInitDone) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, {
if context_mgr.allow_untrusted_code() {
xous::return_scalar(msg.sender, 1).unwrap();
} else {
xous::return_scalar(msg.sender, 0).unwrap();
}
}),
Some(Opcode::RegisterUx) => {
let mut buffer = unsafe{ Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let registration = buffer.to_original::<UxRegistration, _>().unwrap();
let init_focus_found = if registration.app_name.as_str().unwrap_or("UTF-8 error") == INITIAL_APP_FOCUS {
true
} else {
false
};
// note that we are currently assigning all Ux registrations a trust level consistent with a boot context (ultimately trusted)
// this needs to be modified later on once we allow post-boot apps to be created
let token = context_mgr.register(&gfx, &trng, &status_cliprect, &mut canvases,
registration);
// compute what canvases are drawable
// this _replaces_ the original canvas structure, to avoid complications of tracking mutable references through compound data structures
// this is broken into two steps because of https://github.com/rust-lang/rust/issues/71126
recompute_canvases(&canvases);
buffer.replace(Return::UxToken(token)).unwrap();
// fire off a thread that deals with activating the initial boot context. You need this because this call has to complete before the context can respond to activation events.
if token.is_some() & init_focus_found {
std::thread::spawn({
let gam_token = gam_token.clone();
let conn = CB_TO_MAIN_CONN.load(Ordering::SeqCst);
move || {
let switchapp = SwitchToApp {
token: gam_token,
app_name: String::<128>::from_str(INITIAL_APP_FOCUS),
};
let buf = Buffer::into_buf(switchapp).or(Err(xous::Error::InternalError))?;
buf.send(conn, Opcode::SwitchToApp.to_u32().unwrap()).or(Err(xous::Error::InternalError)).map(|_|())
}
});
}
},
Some(Opcode::SetAudioOpcode) => {
let buffer = unsafe{ Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let audio_op = buffer.to_original::<SetAudioOpcode, _>().unwrap();
context_mgr.set_audio_op(audio_op);
},
Some(Opcode::InputLine) => {
// receive the keyboard input and pass it on to the context with focus
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let inputline = buffer.to_original::<String::<4000>, _>().unwrap();
log::debug!("received input line, forwarding on... {}", inputline);
context_mgr.forward_input(inputline).expect("couldn't forward input line to focused app");
log::debug!("returned from forward_input");
},
Some(Opcode::KeyboardEvent) => msg_scalar_unpack!(msg, k1, k2, k3, k4, {
let keys = [
core::char::from_u32(k1 as u32).unwrap_or('\u{0000}'),
core::char::from_u32(k2 as u32).unwrap_or('\u{0000}'),
core::char::from_u32(k3 as u32).unwrap_or('\u{0000}'),
core::char::from_u32(k4 as u32).unwrap_or('\u{0000}'),
];
context_mgr.key_event(keys, &gfx, &mut canvases);
}),
Some(Opcode::Vibe) => msg_scalar_unpack!(msg, ena, _, _, _, {
if ena != 0 { context_mgr.vibe(true) }
else { context_mgr.vibe(false) }
}),
Some(Opcode::ToggleMenuMode) => msg_scalar_unpack!(msg, t1, t2, t3, t4, {
let token = [t1 as u32, t2 as u32, t3 as u32, t4 as u32];
context_mgr.toggle_menu_mode(token);
}),
Some(Opcode::RevertFocus) => {
match context_mgr.revert_focus(&gfx, &mut canvases) {
Ok(_) => xous::return_scalar(msg.sender, 0).expect("couldn't unblock caller"),
_ => xous::return_scalar(msg.sender, 1).expect("couldn't unblock caller"),
}
},
Some(Opcode::RevertFocusNb) => {
match context_mgr.revert_focus(&gfx, &mut canvases) {
_ => log::warn!("failed to revert focus, silent error!"),
}
},
Some(Opcode::QueryGlyphProps) => msg_blocking_scalar_unpack!(msg, style, _, _, _, {
let height = gfx.glyph_height_hint(GlyphStyle::from(style)).expect("couldn't query glyph height from gfx");
xous::return_scalar(msg.sender, height).expect("could not return QueryGlyphProps request");
}),
Some(Opcode::RedrawIme) => {
context_mgr.redraw_imef().expect("couldn't redraw the IMEF");
},
Some(Opcode::SwitchToApp) => {
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let switchapp = buffer.to_original::<SwitchToApp, _>().unwrap();
log::debug!("trying to switch to {:?} with token {:?}", switchapp.app_name.as_str().unwrap(), switchapp.token);
if let Some(new_app_token) = context_mgr.find_app_token_by_name(switchapp.app_name.as_str().unwrap()) {
if new_app_token != context_mgr.focused_app().unwrap_or([0, 0, 0, 0]) {
// two things:
// 1. [0, 0, 0, 0] is simply a very unlikely GID because it's a 128 bit TRNG, and this allows us to handle
// the power-on case where we have no focused app cleanly.
// 2. the `activate()` method on `context_mgr` does not handle app-to-app switches when you're the same app.
// this is because there is a rule which says if you're going to put an app on top of an app, take the old
// app and hide it, while also taking the new app and showing it. This is a race condition, and it results
// in the "same-app" switch ending up in a hidden state, because within the routine the entering state is
// set before the leaving state due to interior-mutability issues (see the block under the debug statement
// titled "resolving visibility rules"). The fix is to simply not issue a context switch if it's the same app.
// It saves CPU thrashing and also works around this problem. (see issue #145)
let authorized_switchers = vec![MAIN_MENU_NAME, ROOTKEY_MODAL_NAME, gam::STATUS_BAR_NAME];
for switchers in authorized_switchers {
if let Some(auth_token) = context_mgr.find_app_token_by_name(switchers) {
if auth_token == switchapp.token {
context_mgr.notify_app_switch(new_app_token)
.unwrap_or_else(|_| {log::warn!("Application does not recognize focus changes")});
match context_mgr.activate(&gfx, &mut canvases, new_app_token, false) {
Ok(_) => (),
Err(_) => log::warn!("failed to switch to {}, silent error!", switchapp.app_name.as_str().unwrap()),
}
continue;
}
}
}
// this message came from ourselves
if gam_token == switchapp.token {
match context_mgr.activate(&gfx, &mut canvases, new_app_token, true) {
Ok(_) => (),
Err(_) => log::warn!("failed to switch to {}, silent error!", switchapp.app_name.as_str().unwrap()),
}
}
}
}
},
Some(Opcode::RaiseMenu) => {
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut activation = buffer.to_original::<GamActivation, _>().unwrap();
log::debug!("got request to raise context {}", activation.name);
let result = context_mgr.raise_menu(activation.name.as_str().unwrap(), &gfx, &mut canvases);
activation.result = Some(
match result {
Ok(_) => ActivationResult::Success,
Err(_) => ActivationResult::Failure,
});
buffer.replace(activation).unwrap();
},
Some(Opcode::Devboot) => msg_scalar_unpack!(msg, ena, _, _, _, {
if ena != 0 { gfx.set_devboot(true).expect("couldn't send devboot message"); }
else { gfx.set_devboot(false).expect("couldn't send devboot message"); }
}),
Some(Opcode::TestPattern) => msg_blocking_scalar_unpack!(msg, duration_ms, _, _, _, {
if !did_test {
did_test = true;
let checked_duration = if duration_ms > 60_000 {
60_000
} else {
duration_ms
};
gfx.selftest(checked_duration);
}
xous::return_scalar(msg.sender, 1).expect("couldn't ack self test");
}),
Some(Opcode::Quit) => break,
None => {log::error!("unhandled message {:?}", msg);}
}
// we don't currently have a mechanism to guarantee that the default app has focus
// right now, it just depends upon it requesting focus, and none others taking it.
// probably something should be inserted around here to take care of that?
}
// clean up our program
log::trace!("main loop exit, destroying servers");
xns.unregister_server(gam_sid).unwrap();
xous::destroy_server(gam_sid).unwrap();
log::trace!("quitting");
xous::terminate_process(0)
}