diff --git a/services/gam/src/api.rs b/services/gam/src/api.rs index 7a618142d..42dc1e403 100644 --- a/services/gam/src/api.rs +++ b/services/gam/src/api.rs @@ -207,6 +207,16 @@ pub(crate) enum MenuMgrOp { Ok, Err, } +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, PartialEq, Eq)] +pub enum ActivationResult { + Success, + Failure, +} +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +pub(crate) struct GamActivation { + pub(crate) name: xous_ipc::String::<128>, + pub(crate) result: Option, +} #[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] pub(crate) struct MenuManagement { diff --git a/services/gam/src/canvas.rs b/services/gam/src/canvas.rs index ddd13b24b..934cb2e6f 100644 --- a/services/gam/src/canvas.rs +++ b/services/gam/src/canvas.rs @@ -5,18 +5,22 @@ use core::cmp::Ordering; use graphics_server::*; use log::{error, info}; +// "Drawable" vs "NotDrawable" is a security distinction. +// "OnScreen" vs "Offscreen" is a layout distinction. #[derive(Debug, Copy, Clone, Eq, PartialEq)] pub enum CanvasState { - // the initial state of every Canvas. Not drawable. - Created, - // this state indicates the Canvas can be drawn, and may or may not need to be flushed to the screen. + // this state indicates the Canvas is on-screen and can be drawn, and may or may not need to be flushed to the screen. DrawableDirty, - // this state indicates the Canvas has been flushed to the screen. + // this state indicates the Canvas is on-screen and has been flushed to the screen. DrawableDrawn, - // indicates that the Canvas is not drawable, but needs to be defaced + // indicates that the Canvas is on-screen but not drawable, but needs to be defaced NotDrawableDirty, - // indicates that the Canvas is not drawable, and has been defaced + // indicates that the Canvas is on-screen not drawable, and has been defaced NotDrawableDefaced, + // indicates that the Canvas was drawable, but is now off-screen and should not be drawn or considered for any computations + OffScreenDrawable, + // indicates that the Canvas was not drawable, but is now off-screen and shouldn to be drawn or considered for any computations + OffScreenNotDrawable, } /// A rectangular region that defines a top-left zero relative offset for graphical items @@ -53,25 +57,40 @@ impl Canvas { Ok(if pan_offset.is_some() { Canvas { - clip_rect, trust_level, state: CanvasState::Created, gid: Gid::new(gid), pan_offset: pan_offset.unwrap(), + clip_rect, trust_level, state: CanvasState::OffScreenDrawable, gid: Gid::new(gid), pan_offset: pan_offset.unwrap(), canvas_type, } } else { Canvas { - clip_rect, trust_level, state: CanvasState::Created, gid: Gid::new(gid), pan_offset: Point::new(0, 0), + clip_rect, trust_level, state: CanvasState::OffScreenNotDrawable, gid: Gid::new(gid), pan_offset: Point::new(0, 0), canvas_type, } }) } pub fn pan_offset(&self) -> Point { self.pan_offset } pub fn clip_rect(&self) -> Rectangle { self.clip_rect } - pub fn set_clip(&mut self, cr: Rectangle) { self.clip_rect = cr; self.state = CanvasState::Created } + pub fn set_clip(&mut self, cr: Rectangle) { self.clip_rect = cr; self.state = CanvasState::OffScreenNotDrawable } pub fn gid(&self) -> Gid { self.gid } pub fn trust_level(&self) -> u8 { self.trust_level } pub fn set_trust_level(&mut self, level: u8) {self.trust_level = level;} pub fn state(&self) -> CanvasState { self.state } + pub fn is_onscreen(&self) -> bool { + if self.state == CanvasState::OffScreenDrawable || self.state == CanvasState::OffScreenNotDrawable { + false + } else { + true + } + } pub fn is_drawable(&self) -> bool { - if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn { + if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn || self.state == CanvasState::OffScreenDrawable { + true + } else { + false + } + } + pub fn is_drawable_or_offscreen(&self) -> bool { + if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn + || self.state == CanvasState::OffScreenDrawable { true } else { false @@ -79,24 +98,47 @@ impl Canvas { } pub fn set_drawable(&mut self, drawable: bool) { if drawable { - if self.state != CanvasState::DrawableDrawn { + if self.state == CanvasState::OffScreenNotDrawable { + self.state = CanvasState::OffScreenDrawable + } else if self.state != CanvasState::DrawableDrawn { self.state = CanvasState::DrawableDirty; } } else { - if self.state != CanvasState::NotDrawableDefaced { + if self.state == CanvasState::OffScreenDrawable { + self.state = CanvasState::OffScreenNotDrawable + } else if self.state != CanvasState::NotDrawableDefaced { self.state = CanvasState::NotDrawableDirty; } } } + pub fn set_onscreen(&mut self, onscreen: bool) { + if onscreen { + if self.state == CanvasState::OffScreenDrawable { + self.state = CanvasState::DrawableDirty; + } else if self.state == CanvasState::OffScreenNotDrawable { + self.state = CanvasState::NotDrawableDirty; + } + // other states are already onscreen + } else { + if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn { + self.state = CanvasState::OffScreenDrawable; + } else if self.state == CanvasState::NotDrawableDirty || self.state == CanvasState::NotDrawableDefaced { + self.state = CanvasState::OffScreenNotDrawable; + } + // other states are already offscreen + } + } // call this after the screen has been flushed pub fn do_flushed(&mut self) -> Result<(), xous::Error> { if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn { self.state = CanvasState::DrawableDrawn; Ok(()) - } else if self.state == CanvasState::NotDrawableDefaced { + } else if self.state == CanvasState::NotDrawableDefaced + || self.state == CanvasState::OffScreenNotDrawable + || self.state == CanvasState::OffScreenDrawable { Ok(()) } else { - error!("Canvas: flush happened before not drawable regions were defaced, or before initialized!"); + error!("Canvas: flush happened before not drawable regions were defaced, or before initialized! {:?}", self.state); Err(xous::Error::UseBeforeInit) } } @@ -256,47 +298,67 @@ pub fn recompute_canvases(canvases: &HashMap, screen: Rectangle) -> } // now, descend through trust levels and compute intersections, putting the updated drawable states into higher_clipregions - let mut higher_clipregions: BinaryHeap = BinaryHeap::new(); - let mut trust_level: u8 = 255; + let mut higher_clipregions: BinaryHeap<&Canvas> = BinaryHeap::new(); + let mut current_trust_level: u8 = 255; // sorted_clipregions is a Max heap keyed on trust, so popping the elements off will return them sorted from most to least trusted if debug{info!("CANVAS: received screen argument of {:?}", screen);} if debug{info!("CANVAS: now determining which regions are drawable");} + + let mut sorted_clipregions_vec = sorted_clipregions.into_sorted_vec(); + for canvas in sorted_clipregions_vec.iter_mut() { + if canvas.is_onscreen() { + if canvas.trust_level() < current_trust_level { + current_trust_level = canvas.trust_level(); + } + for region in higher_clipregions.iter() { + if region.is_onscreen() + && (region.trust_level() > current_trust_level) // regions of same trust level have arbitrary draw order + && region.clip_rect().intersects(canvas.clip_rect()) { + canvas.set_drawable(false); + } else { + canvas.set_drawable(true); + } + } + } + higher_clipregions.push(canvas); + } + /* loop { if let Some(c) = sorted_clipregions.pop() { if debug { info!(" CANVAS: considering {:?}", c);} let mut canvas = c.clone(); let mut drawable: bool = true; - let clip_region = canvas.clip_rect(); - if trust_level < canvas.trust_level() { + if canvas.trust_level() < trust_level { trust_level = canvas.trust_level(); } - if !clip_region.intersects(screen) { - drawable = false; - if debug { info!(" * CANVAS: not drawable, does not intersect");} - } else { // short circuit this computation if it's not drawable because it's off screen + //if !clip_region.intersects(screen) { + // drawable = false; + // if debug { info!(" * CANVAS: not drawable, does not intersect");} + //} else { // short circuit this computation if it's not drawable because it's off screen // note that this .iter() is *not* sorted by trust level, but all elements will be of greater than or equal to the current trust level for ®ion in higher_clipregions.iter() { // regions of the same trust level can draw over each other. Draw order is arbitrary. if region.clip_rect().intersects(clip_region) && (region.trust_level() < trust_level) { + log::info!("{:?} {:?}->false", canvas.canvas_type, canvas.state); drawable = false; if debug { info!(" * CANVAS: not drawable, lower trust intersecting with higher trust region");} } } - } + //} canvas.set_drawable(drawable); higher_clipregions.push(canvas); } else { break; } - } + }*/ // create a new index map out of the recomputed higher_clipregions let mut map: HashMap = HashMap::new(); if debug { info!("CANVAS: reconstituting index map");} for &c in higher_clipregions.iter() { if debug { info!(" CANVAS: inserting gid {:?}, canvas {:?}", c.gid(), c);} - map.insert(c.gid(), c); + map.insert(c.gid(), *c); } map diff --git a/services/gam/src/contexts.rs b/services/gam/src/contexts.rs index cad8fdafb..d96fe412a 100644 --- a/services/gam/src/contexts.rs +++ b/services/gam/src/contexts.rs @@ -309,7 +309,7 @@ impl ContextManager { canvases: &mut HashMap, token: [u32; 4], clear: bool, - ) { + ) -> ActivationResult { let mut leaving_visibility: bool = false; { // using a temp copy of the old focus, check if we need to update any visibility state @@ -329,6 +329,8 @@ impl ContextManager { if token != leaving_focused_context.app_token { if (context.layout.behavior() == LayoutBehavior::Alert) && (leaving_focused_context.layout.behavior() == LayoutBehavior::Alert) { + // left off: determine if the currently visible context is a password field. if it is, deny the activation. + context.layout.set_visibility_state(true, canvases); //leaving_focused_context.layout.set_visibility_state(false, canvases); leaving_visibility = false; @@ -438,6 +440,7 @@ impl ContextManager { log::trace!("activate redraw"); self.redraw().expect("couldn't redraw the currently focused app"); } + ActivationResult::Success } pub(crate) fn revert_focus(&mut self, gfx: &graphics_server::Gfx, @@ -565,7 +568,7 @@ impl ContextManager { name: &str, gfx: &graphics_server::Gfx, canvases: &mut HashMap, - ) { + ) -> ActivationResult { log::debug!("looking for menu {}", name); if let Some(token) = self.find_app_token_by_name(name) { log::debug!("found menu token: {:?}", token); @@ -575,10 +578,11 @@ impl ContextManager { // but alerts can be raised without authentication if context.layout.behavior() == LayoutBehavior::Alert { log::debug!("activating context"); - self.activate(gfx, canvases, token, false); + return self.activate(gfx, canvases, token, false) } } } + ActivationResult::Failure } } diff --git a/services/gam/src/layouts/chat.rs b/services/gam/src/layouts/chat.rs index fb7a07003..617ba106c 100644 --- a/services/gam/src/layouts/chat.rs +++ b/services/gam/src/layouts/chat.rs @@ -22,7 +22,6 @@ pub(crate) struct ChatLayout { screensize: Point, _small_height: i16, _regular_height: i16, - visible: bool, } impl ChatLayout { // pass in the status canvas so we can size around it, but we can't draw on it @@ -65,7 +64,6 @@ impl ChatLayout { screensize, _small_height: small_height, _regular_height: regular_height, - visible: true, }) } } @@ -139,32 +137,14 @@ impl LayoutApi for ChatLayout { ] } fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap) { - log::debug!("request modal to onscreen {} from self.visible {}", onscreen, self.visible); - if onscreen == self.visible { - log::trace!("chatlayout: no change to visibility, moving on"); - // nothing to do - return - } - let offscreen = if !onscreen && self.visible { - // move canvases off-screen - Point::new(self.screensize.x*2, 0) - } else if onscreen && !self.visible { - // undo the off-screen move - Point::new(-self.screensize.x*2, 0) - } else { - // should actually never reach this because of the identity check at the very top - Point::new(0, 0) - }; - log::debug!("chatlayout: shifting canvas for input by {:?}", offscreen); let input_canvas = canvases.get_mut(&self.input).expect("couldn't find input canvas"); - input_canvas.set_clip(input_canvas.clip_rect().translate_chain(offscreen)); + log::debug!("request modal to onscreen {}->{}", input_canvas.is_onscreen(), onscreen); + input_canvas.set_onscreen(onscreen); let content_canvas = canvases.get_mut(&self.content).expect("couldn't find content canvas"); - content_canvas.set_clip(content_canvas.clip_rect().translate_chain(offscreen)); + content_canvas.set_onscreen(onscreen); let predictive_canvas = canvases.get_mut(&self.predictive).expect("couldn't find predictive canvas"); - predictive_canvas.set_clip(predictive_canvas.clip_rect().translate_chain(offscreen)); - - self.visible = onscreen; + predictive_canvas.set_onscreen(onscreen); } } \ No newline at end of file diff --git a/services/gam/src/layouts/framebuffer.rs b/services/gam/src/layouts/framebuffer.rs index aa4cd4de9..8b1353c98 100644 --- a/services/gam/src/layouts/framebuffer.rs +++ b/services/gam/src/layouts/framebuffer.rs @@ -10,7 +10,6 @@ const TRUST_OFFSET: u8 = 4; pub(crate) struct Framebuffer { pub gid: Gid, screensize: Point, - visible: bool, } impl Framebuffer { pub fn init( @@ -30,7 +29,6 @@ impl Framebuffer { Ok(Framebuffer { gid: fb_canvas.gid(), screensize, - visible: true, }) } } @@ -63,25 +61,8 @@ impl LayoutApi for Framebuffer { ] } fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap) { - log::debug!("raw fb entering set_visibilty_state, self.visible {}, onscreen {}", self.visible, onscreen); - if onscreen == self.visible { - // nothing to do - return - } let fb_canvas = canvases.get_mut(&self.gid).expect("couldn't find my canvas"); - - let offscreen = if !onscreen && self.visible { - // move canvases off-screen - Point::new(self.screensize.x*2, 0) - } else if onscreen && !self.visible { - // undo the off-screen move - Point::new(-self.screensize.x*2, 0) - } else { - // should actually never reach this because of the identity check at the very top - Point::new(0, 0) - }; - fb_canvas.set_clip(fb_canvas.clip_rect().translate_chain(offscreen)); - self.visible = onscreen; - log::debug!("moving raw framebuffer box by {:?}, final state: {:?}", offscreen, fb_canvas); + log::debug!("raw fb entering set_visibilty_state, {}->{}", fb_canvas.is_onscreen(), onscreen); + fb_canvas.set_onscreen(onscreen); } } \ No newline at end of file diff --git a/services/gam/src/layouts/menu.rs b/services/gam/src/layouts/menu.rs index 2c2a2903b..10f918c5f 100644 --- a/services/gam/src/layouts/menu.rs +++ b/services/gam/src/layouts/menu.rs @@ -17,7 +17,6 @@ pub(crate) struct MenuLayout { menu_min_height: i16, screensize: Point, _height: i16, - visible: bool, } impl MenuLayout { pub fn init(gfx: &graphics_server::Gfx, trng: &trng::Trng, canvases: &mut HashMap) -> Result { @@ -41,7 +40,6 @@ impl MenuLayout { menu_min_height: height, screensize, _height: height, // start with "minimum" size and grow up as items are added - visible: true, }) } } @@ -83,25 +81,8 @@ impl LayoutApi for MenuLayout { ] } fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap) { - log::debug!("menu entering set_visibilty_state, self.visible {}, onscreen {}", self.visible, onscreen); - if onscreen == self.visible { - // nothing to do - return - } let menu_canvas = canvases.get_mut(&self.menu).expect("couldn't find menu canvas"); - - let offscreen = if !onscreen && self.visible { - // move canvases off-screen - Point::new(self.screensize.x*2, 0) - } else if onscreen && !self.visible { - // undo the off-screen move - Point::new(-self.screensize.x*2, 0) - } else { - // should actually never reach this because of the identity check at the very top - Point::new(0, 0) - }; - log::debug!("moving menu by {:?}", offscreen); - menu_canvas.set_clip(menu_canvas.clip_rect().translate_chain(offscreen)); - self.visible = onscreen; + log::debug!("menu entering set_visibilty_state, {}->{}", menu_canvas.is_onscreen(), onscreen); + menu_canvas.set_onscreen(onscreen); } } diff --git a/services/gam/src/layouts/modal.rs b/services/gam/src/layouts/modal.rs index 35b56334f..d66a7b1e6 100644 --- a/services/gam/src/layouts/modal.rs +++ b/services/gam/src/layouts/modal.rs @@ -18,7 +18,6 @@ pub(crate) struct ModalLayout { modal_min_height: i16, screensize: Point, _height: i16, - visible: bool, _modal_y_max: i16, } impl ModalLayout { @@ -43,7 +42,6 @@ impl ModalLayout { modal_min_height: height, screensize, _height: screensize.y - MODAL_Y_PAD, // start with the "maximum" size, and shrink down once items are known - visible: true, _modal_y_max: crate::api::MODAL_Y_MAX, }) } @@ -87,25 +85,8 @@ impl LayoutApi for ModalLayout { } fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap) { - log::debug!("modal box entering set_visibilty_state, self.visible {}, onscreen {}", self.visible, onscreen); - if onscreen == self.visible { - // nothing to do - return - } let modal_canvas = canvases.get_mut(&self.modal).expect("couldn't find modal canvas"); - - let offscreen = if !onscreen && self.visible { - // move canvases off-screen - Point::new(self.screensize.x*2, 0) - } else if onscreen && !self.visible { - // undo the off-screen move - Point::new(-self.screensize.x*2, 0) - } else { - // should actually never reach this because of the identity check at the very top - Point::new(0, 0) - }; - modal_canvas.set_clip(modal_canvas.clip_rect().translate_chain(offscreen)); - self.visible = onscreen; - log::debug!("moving modal box by {:?}, final state: {:?}", offscreen, modal_canvas); + log::debug!("modal box entering set_visibilty_state {}->{}", modal_canvas.is_onscreen(), onscreen); + modal_canvas.set_onscreen(onscreen); } } \ No newline at end of file diff --git a/services/gam/src/lib.rs b/services/gam/src/lib.rs index 39c2225d5..494ccf667 100644 --- a/services/gam/src/lib.rs +++ b/services/gam/src/lib.rs @@ -343,12 +343,21 @@ impl Gam { let buf = Buffer::into_buf(switchapp).or(Err(xous::Error::InternalError))?; buf.send(self.conn, Opcode::SwitchToApp.to_u32().unwrap()).or(Err(xous::Error::InternalError)).map(|_|()) } - pub fn raise_menu(&self, menu_name: &str) -> Result<(), xous::Error> { - let menu_name = String::<128>::from_str(menu_name); - let buf = Buffer::into_buf(menu_name).or(Err(xous::Error::InternalError))?; - buf.send(self.conn, Opcode::RaiseMenu.to_u32().unwrap()).or(Err(xous::Error::InternalError)).map(|_|()) + pub fn raise_menu(&self, menu_name: &str) -> Result { + let menu_name = GamActivation { + name: String::<128>::from_str(menu_name), + result: None, + }; + let mut buf = Buffer::into_buf(menu_name).or(Err(xous::Error::InternalError))?; + buf.lend_mut(self.conn, Opcode::RaiseMenu.to_u32().unwrap()).or(Err(xous::Error::InternalError)).expect("couldn't send RaiseMenu opcode"); + let result = buf.to_original::().unwrap(); + if let Some(code) = result.result { + Ok(code) + } else { + Err(xous::Error::InternalError) + } } - pub fn raise_modal(&self, modal_name: &str) -> Result<(), xous::Error> { + pub fn raise_modal(&self, modal_name: &str) -> Result { self.raise_menu(modal_name) } /// this is a one-way door, once you've set it, you can't unset it. diff --git a/services/gam/src/main.rs b/services/gam/src/main.rs index baeb41272..25c75fe23 100644 --- a/services/gam/src/main.rs +++ b/services/gam/src/main.rs @@ -59,12 +59,14 @@ fn xmain() -> ! { 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( + let mut 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"); + status_canvas.set_onscreen(true); + status_canvas.set_drawable(true); canvases.insert(status_canvas.gid(), status_canvas); canvases = recompute_canvases(&canvases, Rectangle::new(Point::new(0, 0), screensize)); @@ -193,9 +195,9 @@ fn xmain() -> ! { } log::trace!("render request for {:?}", tv); - tv.set_dry_run(false); 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 @@ -204,7 +206,7 @@ fn xmain() -> ! { continue; } // first, figure out if we should even be drawing to this canvas. - if canvas.is_drawable() { // dry runs should not move any pixels so they are OK to go through in any case + 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()); @@ -222,7 +224,9 @@ fn xmain() -> ! { let ret = api::Return::RenderReturn(tv); buffer.replace(ret).unwrap(); - canvas.do_drawn().expect("couldn't set canvas to drawn"); + 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; @@ -299,7 +303,7 @@ fn xmain() -> ! { 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. - if canvas.is_drawable() { + if canvas.is_drawable() && canvas.is_onscreen() { match obj.obj { GamObjectType::Line(mut line) => { line.translate(canvas.clip_rect().tl); @@ -348,7 +352,7 @@ fn xmain() -> ! { let obj_ipc = buffer.to_original::().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() { + 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 { @@ -508,10 +512,12 @@ fn xmain() -> ! { } }, Some(Opcode::RaiseMenu) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let menu_name = buffer.to_original::, _>().unwrap(); - log::debug!("got request to raise menu {}", menu_name); - context_mgr.raise_menu(menu_name.as_str().unwrap(), &gfx, &mut canvases); + let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let mut activation = buffer.to_original::().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(result); + 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"); } diff --git a/services/gam/src/modal.rs b/services/gam/src/modal.rs index a4720ac09..ef694704c 100644 --- a/services/gam/src/modal.rs +++ b/services/gam/src/modal.rs @@ -330,7 +330,11 @@ impl<'a> Modal<'a> { modal } pub fn activate(&self) { - self.gam.raise_modal(self.name.to_str()).expect("couldn't activate modal"); + let tt = ticktimer_server::Ticktimer::new().unwrap(); + while self.gam.raise_modal(self.name.to_str()).expect("couldn't activate modal") != ActivationResult::Success { + // wait a bit then try again + tt.sleep_ms(857).unwrap(); + } } /// this function spawns a client-side thread to forward redraw and key event diff --git a/services/modals/Cargo.toml b/services/modals/Cargo.toml index e2722a8b9..bc3ec35f4 100644 --- a/services/modals/Cargo.toml +++ b/services/modals/Cargo.toml @@ -24,4 +24,4 @@ utralib = { path = "../../utralib"} [features] ux_tests = [] -default = [] +default = ["ux_tests"] diff --git a/services/modals/src/main.rs b/services/modals/src/main.rs index 449cc957d..829434d22 100644 --- a/services/modals/src/main.rs +++ b/services/modals/src/main.rs @@ -387,6 +387,7 @@ fn xmain() -> ! { }); if cfg!(feature = "ux_tests") { + tt.sleep_ms(1000).unwrap(); tests::spawn_test(); } diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index c4ecffedd..f825139b2 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -420,8 +420,6 @@ fn xmain() -> ! { let xns = xous_names::XousNames::new().unwrap(); let pddb_sid = xns.register_name(api::SERVER_NAME_PDDB, None).expect("can't register server"); log::trace!("registered with NS -- {:?}", pddb_sid); - #[cfg(not(any(windows, unix)))] // avoid errors in hosted mode - let tt = ticktimer_server::Ticktimer::new().unwrap(); log::trace!("ready to accept requests"); @@ -469,7 +467,9 @@ fn xmain() -> ! { } }); // try to mount the PDDB automatically before starting the server - #[cfg(not(any(windows, unix)))] // skip this step if running in hosted mode, for now... + //#[cfg(not(any(windows, unix)))] // avoid errors in hosted mode + let tt = ticktimer_server::Ticktimer::new().unwrap(); + //#[cfg(not(any(windows, unix)))] // skip this step if running in hosted mode, for now... if pddb_os.rootkeys_initialized() { tt.sleep_ms(1000).unwrap(); // wait 1 second after boot before attempting to mount, to let the boot screen finish redrawing (cometic issue). match ensure_password(&modals, &mut pddb_os) { diff --git a/services/root-keys/src/main.rs b/services/root-keys/src/main.rs index db73ad114..8f37a1e9d 100644 --- a/services/root-keys/src/main.rs +++ b/services/root-keys/src/main.rs @@ -193,7 +193,7 @@ mod implementation { false } pub fn is_pcache_boot_password_valid(&self) -> bool { - true + false } pub fn fpga_key_source(&self) -> FpgaKeySource { FpgaKeySource::Efuse