part-way through a refactor of trust levels to prevent alerts from popping over password boxes

This commit is contained in:
bunnie 2022-02-04 23:59:20 +08:00
parent b35f2a1d3e
commit 08421999ad
14 changed files with 155 additions and 136 deletions

View file

@ -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<ActivationResult>,
}
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
pub(crate) struct MenuManagement {

View file

@ -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<Gid, Canvas>, screen: Rectangle) ->
}
// now, descend through trust levels and compute intersections, putting the updated drawable states into higher_clipregions
let mut higher_clipregions: BinaryHeap<Canvas> = 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 &region 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<Gid, Canvas> = 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

View file

@ -309,7 +309,7 @@ impl ContextManager {
canvases: &mut HashMap<Gid, Canvas>,
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<Gid, Canvas>,
) {
) -> 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
}
}

View file

@ -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<Gid, Canvas>) {
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);
}
}

View file

@ -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<Gid, Canvas>) {
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);
}
}

View file

@ -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<Gid, Canvas>) -> Result<MenuLayout, xous::Error> {
@ -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<Gid, Canvas>) {
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);
}
}

View file

@ -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<Gid, Canvas>) {
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);
}
}

View file

@ -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<ActivationResult, xous::Error> {
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::<GamActivation, _>().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<ActivationResult, xous::Error> {
self.raise_menu(modal_name)
}
/// this is a one-way door, once you've set it, you can't unset it.

View file

@ -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::<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() {
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::<String::<128>, _>().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::<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(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"); }

View file

@ -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

View file

@ -24,4 +24,4 @@ utralib = { path = "../../utralib"}
[features]
ux_tests = []
default = []
default = ["ux_tests"]

View file

@ -387,6 +387,7 @@ fn xmain() -> ! {
});
if cfg!(feature = "ux_tests") {
tt.sleep_ms(1000).unwrap();
tests::spawn_test();
}

View file

@ -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) {

View file

@ -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