diff --git a/services/modals/src/api.rs b/services/modals/src/api.rs index 3838b9d51..3e9f53759 100644 --- a/services/modals/src/api.rs +++ b/services/modals/src/api.rs @@ -89,7 +89,31 @@ pub(crate) enum Opcode { /// close dynamic notification CloseDynamicNotification, + /// used by libraries to get the mutex on the server GetMutex, + // these are used internally by the modals to handle intermediate state. Do not call from the outside. + // these were originally handled in a separate thread for deferred responses using busy-waits. They are + // now handled with deferred responses with makes code less complicated and less load on the CPU but + // it does expose some of the internal API mechanics to outside processes. This is fine for the modals + // box because it's a convenience routine used by "everyone"; password boxes are always handled within + // a given secured server so that the attack surface for these do not extend into the modals boundary. + InitiateOp, + DoUpdateProgress, + FinishProgress, + + TextEntryReturn, + RadioReturn, + CheckBoxReturn, + NotificationReturn, + + DoUpdateDynamicNotification, + DoCloseDynamicNotification, + + ModalRedraw, + ModalKeypress, + ModalDrop, + Gutter, + Quit, } diff --git a/services/modals/src/lib.rs b/services/modals/src/lib.rs index 8d76229a5..648e62f4e 100644 --- a/services/modals/src/lib.rs +++ b/services/modals/src/lib.rs @@ -8,10 +8,12 @@ use xous::{CID, SID, send_message, Message}; use num_traits::{ToPrimitive, FromPrimitive}; use xous_ipc::Buffer; use std::thread; +use core::cell::Cell; pub struct Modals { conn: CID, token: [u32; 4], + have_lock: Cell::, } impl Modals { pub fn new(xns: &xous_names::XousNames) -> Result { @@ -23,6 +25,7 @@ impl Modals { Ok(Modals { conn, token, + have_lock: Cell::new(false), }) } @@ -78,6 +81,7 @@ impl Modals { unsafe{xous::disconnect(cid).unwrap()}; // must disconnect before destroy to avoid the CID from hanging out in our outbound table which is limited to 32 entries xous::destroy_server(SID::from_array(server)).expect("couldn't destroy temporary server"); } + self.unlock(); match buf.to_original::() { Ok(response) => Ok(response), _ => Err(xous::Error::InternalError) @@ -93,6 +97,7 @@ impl Modals { }; let buf = Buffer::into_buf(spec).or(Err(xous::Error::InternalError))?; buf.lend(self.conn, Opcode::Notification.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; + self.unlock(); Ok(()) } @@ -131,6 +136,7 @@ impl Modals { self.token[3] as usize, ) ).expect("couldn't stop progress"); + self.unlock(); Ok(()) } @@ -154,6 +160,7 @@ impl Modals { let mut buf = Buffer::into_buf(spec).or(Err(xous::Error::InternalError))?; buf.lend_mut(self.conn, Opcode::PromptWithFixedResponse.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; let itemname = buf.to_original::().unwrap(); + self.unlock(); Ok(String::from(itemname.as_str())) } @@ -172,6 +179,7 @@ impl Modals { ret.push(String::from(item.as_str())); } } + self.unlock(); Ok(ret) } @@ -197,7 +205,6 @@ impl Modals { Ok(()) } pub fn dynamic_notification_close(&self) -> Result<(), xous::Error> { - self.lock(); send_message(self.conn, Message::new_scalar(Opcode::CloseDynamicNotification.to_usize().unwrap(), self.token[0] as usize, @@ -206,28 +213,35 @@ impl Modals { self.token[3] as usize, ) ).expect("couldn't stop progress"); + self.unlock(); Ok(()) } /// Blocks until we have a lock on the modals server fn lock(&self) { - match send_message( - self.conn, - Message::new_blocking_scalar(Opcode::GetMutex.to_usize().unwrap(), - self.token[0] as usize, - self.token[1] as usize, - self.token[2] as usize, - self.token[3] as usize, - )).expect("couldn't send mutex acquisition message") { - xous::Result::Scalar1(code) => { - if code != 1 { - log::warn!("Unexpected return from lock acquisition."); + if !self.have_lock.get() { + match send_message( + self.conn, + Message::new_blocking_scalar(Opcode::GetMutex.to_usize().unwrap(), + self.token[0] as usize, + self.token[1] as usize, + self.token[2] as usize, + self.token[3] as usize, + )).expect("couldn't send mutex acquisition message") { + xous::Result::Scalar1(code) => { + if code != 1 { + log::warn!("Unexpected return from lock acquisition."); + } + }, + _ => { + log::error!("Internal error trying to acquire mutex"); } - }, - _ => { - log::error!("Internal error trying to acquire mutex"); } } + self.have_lock.set(true); + } + fn unlock(&self) { + self.have_lock.set(false); } } diff --git a/services/modals/src/main.rs b/services/modals/src/main.rs index 01860692a..ec791836a 100644 --- a/services/modals/src/main.rs +++ b/services/modals/src/main.rs @@ -10,9 +10,6 @@ use xous::SID; use xous::{msg_scalar_unpack, msg_blocking_scalar_unpack, send_message, Message}; use xous_ipc::Buffer; -use std::sync::{Arc, Mutex}; -use std::thread; - use gam::modal::*; #[cfg(feature="tts")] use tts_frontend::TtsFrontend; @@ -33,36 +30,9 @@ enum RendererState { RunText(ManagedPromptWithTextResponse), RunProgress(ManagedProgress), RunNotification(ManagedNotification), - /// response ready state - ResponseText(TextEntryPayload), - ResponseRadio(ItemName), - ResponseCheckBox(CheckBoxPayload), RunDynamicNotification(DynamicNotification), } -#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)] -pub(crate) enum RendererOp { - InitiateOp, - UpdateProgress, - FinishProgress, - - TextEntryReturn, - RadioReturn, - CheckBoxReturn, - NotificationReturn, - - AddModalItem, - - UpdateDynamicNotification, - CloseDynamicNotification, - - ModalRedraw, - ModalKeypress, - ModalDrop, - Quit, - Gutter, -} - #[xous::xous_main] fn xmain() -> ! { log_server::init_wait().unwrap(); @@ -75,354 +45,58 @@ fn xmain() -> ! { let tt = ticktimer_server::Ticktimer::new().unwrap(); - let renderer_sid = xous::create_server().expect("couldn't create a server for the modal UX renderer"); - let renderer_cid = xous::connect(renderer_sid).expect("couldn't connect to the modal UX renderer"); + // we are our own renderer now that we implement deferred responses + let renderer_cid = xous::connect(modals_sid).expect("couldn't connect to the modal UX renderer"); #[cfg(feature="tts")] let tts = TtsFrontend::new(&xns).unwrap(); #[cfg(feature="tts")] let mut last_tick = tt.elapsed_ms(); - let op = Arc::new(Mutex::new(RendererState::None)); - // create a thread that just handles the redrawing requests - let _redraw_handle = thread::spawn({ - let op = Arc::clone(&op); - move || { - #[cfg(feature="tts")] - let tt = ticktimer_server::Ticktimer::new().unwrap(); - // build the core data structure here - let text_action = TextEntry { - is_password: false, - visibility: TextEntryVisibility::Visible, - action_conn: renderer_cid, - action_opcode: RendererOp::TextEntryReturn.to_u32().unwrap(), - action_payload: TextEntryPayload::new(), - validator: None, - }; - let mut fixed_items = Vec::::new(); - let notification = gam::modal::Notification::new( - renderer_cid, - RendererOp::NotificationReturn.to_u32().unwrap() - ); - let mut gutter = gam::modal::Notification::new( - renderer_cid, - RendererOp::Gutter.to_u32().unwrap() - ); - gutter.set_manual_dismiss(false); - let mut progress_action = Slider::new(renderer_cid, RendererOp::Gutter.to_u32().unwrap(), - 0, 100, 1, Some("%"), 0, true, true - ); - let mut last_percentage = 0; - let mut start_work: u32 = 0; - let mut end_work: u32 = 100; - let mut renderer_modal = - Modal::new( - gam::SHARED_MODAL_NAME, - ActionType::TextEntry(text_action), - Some("Placeholder"), - None, - GlyphStyle::Regular, - 8 - ); - renderer_modal.spawn_helper(renderer_sid, renderer_modal.sid, - RendererOp::ModalRedraw.to_u32().unwrap(), - RendererOp::ModalKeypress.to_u32().unwrap(), - RendererOp::ModalDrop.to_u32().unwrap(), - ); + // current opcode being processed by the modals server + let mut op = RendererState::None; + // the message for the deferred response + let mut dr: Option = None; - loop { - let msg = xous::receive_message(renderer_sid).unwrap(); - log::debug!("renderer message: {:?}", msg); - match FromPrimitive::from_usize(msg.body.id()) { - Some(RendererOp::InitiateOp) => { - log::debug!("InitiateOp called"); - let mutex_op = op.lock().unwrap(); - match *mutex_op { - RendererState::RunText(config) => { - log::debug!("initiating text entry modal"); - #[cfg(feature="tts")] - tts.tts_simple(config.prompt.as_str().unwrap()).unwrap(); - renderer_modal.modify( - Some(ActionType::TextEntry(text_action)), - Some(config.prompt.as_str().unwrap()), false, - None, true, None - ); - renderer_modal.activate(); - log::debug!("should be active!"); - }, - RendererState::RunNotification(config) => { - #[cfg(feature="tts")] - tts.tts_simple(config.message.as_str().unwrap()).unwrap(); - renderer_modal.modify( - Some(ActionType::Notification(notification)), - Some(config.message.as_str().unwrap()), false, - None, true, None - ); - renderer_modal.activate(); - }, - RendererState::RunProgress(config) => { - start_work = config.start_work; - end_work = config.end_work; - last_percentage = compute_checked_percentage( - config.current_work, start_work, end_work); - log::debug!("init percentage: {}, current: {}, start: {}, end: {}", last_percentage, config.current_work, start_work, end_work); - progress_action.set_state(last_percentage); - #[cfg(feature="tts")] - tts.tts_simple(config.title.as_str().unwrap()).unwrap(); - renderer_modal.modify( - Some(ActionType::Slider(progress_action)), - Some(config.title.as_str().unwrap()), false, - None, true, None - ); - renderer_modal.activate(); - }, - RendererState::RunRadio(config) => { - let mut radiobuttons = gam::modal::RadioButtons::new( - renderer_cid, - RendererOp::RadioReturn.to_u32().unwrap() - ); - for item in fixed_items.iter() { - radiobuttons.add_item(*item); - } - fixed_items.clear(); - #[cfg(feature="tts")] - { - tts.tts_blocking(t!("modals.radiobutton", xous::LANG)).unwrap(); - tts.tts_blocking(config.prompt.as_str().unwrap()).unwrap(); - } - renderer_modal.modify( - Some(ActionType::RadioButtons(radiobuttons)), - Some(config.prompt.as_str().unwrap()), false, - None, true, None - ); - renderer_modal.activate(); - }, - RendererState::RunCheckBox(config) => { - let mut checkbox = gam::modal::CheckBoxes::new( - renderer_cid, - RendererOp::CheckBoxReturn.to_u32().unwrap() - ); - for item in fixed_items.iter() { - checkbox.add_item(*item); - } - fixed_items.clear(); - #[cfg(feature="tts")] - { - tts.tts_blocking(t!("modals.checkbox", xous::LANG)).unwrap(); - tts.tts_blocking(config.prompt.as_str().unwrap()).unwrap(); - } - renderer_modal.modify( - Some(ActionType::CheckBoxes(checkbox)), - Some(config.prompt.as_str().unwrap()), false, - None, true, None - ); - renderer_modal.activate(); - }, - RendererState::RunDynamicNotification(config) => { - let mut top_text = String::new(); - if let Some(title) = config.title { - #[cfg(feature="tts")] - tts.tts_simple(title.as_str().unwrap()).unwrap(); - top_text.push_str(title.as_str().unwrap()); - } - let mut bot_text = String::new(); - if let Some(text) = config.text { - #[cfg(feature="tts")] - tts.tts_simple(text.as_str().unwrap()).unwrap(); - bot_text.push_str(text.as_str().unwrap()); - } - renderer_modal.modify( - Some(ActionType::Notification(gutter)), - Some(&top_text), config.title.is_none(), - Some(&bot_text), config.text.is_none(), - None - ); - renderer_modal.activate(); - }, - RendererState::None => { - log::error!("Operation initiated with no argument specified. Ignoring request."); - continue; - } - _ => { - log::warn!("unimplemented arm in renderer match"); - unimplemented!(); - } - } - }, - Some(RendererOp::UpdateProgress) => msg_scalar_unpack!(msg, current, _, _, _, { - let new_percentage = compute_checked_percentage( - current as u32, start_work, end_work); - log::trace!("percentage: {}, current: {}, start: {}, end: {}", new_percentage, current, start_work, end_work); - if new_percentage != last_percentage { - last_percentage = new_percentage; - progress_action.set_state(last_percentage); - #[cfg(feature="tts")] - { - if tt.elapsed_ms() - last_tick > TICK_INTERVAL { - tts.tts_blocking(t!("progress.increment", xous::LANG)).unwrap(); - last_tick = tt.elapsed_ms(); - } - } - renderer_modal.modify( - Some(ActionType::Slider(progress_action)), - None, false, - None, false, None - ); - renderer_modal.redraw(); - xous::yield_slice(); // give time for the GAM to redraw - } - }), - Some(RendererOp::FinishProgress) => { - renderer_modal.gam.relinquish_focus().unwrap(); - }, - Some(RendererOp::UpdateDynamicNotification) => { - let mutex_op = op.lock().unwrap(); - match *mutex_op { - RendererState::RunDynamicNotification(config) => { - let mut top_text = String::new(); - if let Some(title) = config.title { - top_text.push_str(title.as_str().unwrap()); - } - let mut bot_text = String::new(); - if let Some(text) = config.text { - bot_text.push_str(text.as_str().unwrap()); - } - renderer_modal.modify( - None, - Some(&top_text), config.title.is_none(), - Some(&bot_text), config.text.is_none(), - None - ); - renderer_modal.redraw(); - } - _ => { - log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - } - } - }, - Some(RendererOp::CloseDynamicNotification) => { - renderer_modal.gam.relinquish_focus().unwrap(); - }, - Some(RendererOp::TextEntryReturn) => { - let mut mutex_op = op.lock().unwrap(); - match *mutex_op { - RendererState::RunText(config) => { - log::trace!("validating text entry modal"); - let buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let text = buf.to_original::().unwrap(); - if let Some(validator_sid) = config.validator { - let cid = xous::connect(SID::from_array(validator_sid)).unwrap(); - let validation = Validation { - text, - opcode: config.validator_op, - }; - let mut buf = Buffer::into_buf(validation).expect("couldn't convert validator structure"); - buf.lend_mut(cid, ValidationOp::Validate.to_u32().unwrap()).expect("validation call failed"); - let response = buf.to_original::>, _>().expect("couldn't unpack validation response"); - unsafe{xous::disconnect(cid).unwrap();} - if let Some(err) = response { - // try again - renderer_modal.modify( - Some(ActionType::TextEntry(text_action)), - Some(config.prompt.as_str().unwrap()), false, - Some(err.as_str().unwrap()), false, None - ); - renderer_modal.activate(); - } else { - // the change in mutex_op enum type will signal the state change to the caller - *mutex_op = RendererState::ResponseText(text); - } - } else { - *mutex_op = RendererState::ResponseText(text); - } - } - RendererState::None => log::warn!("Text entry detected a fat finger event, ignoring."), - _ => { - log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - } - } - } - Some(RendererOp::NotificationReturn) => { - let mut mutex_op = op.lock().unwrap(); - match *mutex_op { - RendererState::RunNotification(_) => *mutex_op = RendererState::None, - RendererState::None => log::warn!("Notification detected a fat finger event, ignoring."), - _ => { - log::error!("UX return opcode does not match our current operation in flight: {:?}", mutex_op); - panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - } - } - }, - Some(RendererOp::Gutter) => { - log::info!("gutter op, doing nothing"); - }, - Some(RendererOp::AddModalItem) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let item = buffer.to_original::().unwrap(); - fixed_items.push(item); - } - Some(RendererOp::RadioReturn) => { - let mut mutex_op = op.lock().unwrap(); - match *mutex_op { - RendererState::RunRadio(_config) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let item = buffer.to_original::().unwrap(); - *mutex_op = RendererState::ResponseRadio(item.0); - } - RendererState::ResponseRadio(_) => log::warn!("Radio buttons detected a fat finger event, ignoring."), - RendererState::None => log::warn!("Radio buttons detected a fat finger event, ignoring."), - _ => { - log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - } - } - } - Some(RendererOp::CheckBoxReturn) => { - let mut mutex_op = op.lock().unwrap(); - match *mutex_op { - RendererState::RunCheckBox(_config) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let item = buffer.to_original::().unwrap(); - *mutex_op = RendererState::ResponseCheckBox(item); - } - RendererState::ResponseCheckBox(_) => log::warn!("Check boxes detected a fat finger event, ignoring."), - RendererState::None => log::warn!("Check boxes detected a fat finger event, ignoring."), - _ => { - log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); - } - } - } - Some(RendererOp::ModalRedraw) => { - renderer_modal.redraw(); - }, - Some(RendererOp::ModalKeypress) => msg_scalar_unpack!(msg, k1, k2, k3, k4, { - let keys = [ - if let Some(a) = core::char::from_u32(k1 as u32) {a} else {'\u{0000}'}, - if let Some(a) = core::char::from_u32(k2 as u32) {a} else {'\u{0000}'}, - if let Some(a) = core::char::from_u32(k3 as u32) {a} else {'\u{0000}'}, - if let Some(a) = core::char::from_u32(k4 as u32) {a} else {'\u{0000}'}, - ]; - renderer_modal.key_event(keys); - }), - Some(RendererOp::ModalDrop) => { // this guy should never quit, it's a core OS service - panic!("Password modal for PDDB quit unexpectedly"); - }, - Some(RendererOp::Quit) => { - log::warn!("received quit on PDDB password UX renderer loop"); - xous::return_scalar(msg.sender, 0).unwrap(); - break; - }, - None => { - log::error!("Couldn't convert opcode: {:?}", msg); - } - } - } - xous::destroy_server(renderer_sid).unwrap(); - } - }); + // build the core data structure here + let text_action = TextEntry { + is_password: false, + visibility: TextEntryVisibility::Visible, + action_conn: renderer_cid, + action_opcode: Opcode::TextEntryReturn.to_u32().unwrap(), + action_payload: TextEntryPayload::new(), + validator: None, + }; + let mut fixed_items = Vec::::new(); + let notification = gam::modal::Notification::new( + renderer_cid, + Opcode::NotificationReturn.to_u32().unwrap() + ); + let mut gutter = gam::modal::Notification::new( + renderer_cid, + Opcode::Gutter.to_u32().unwrap() + ); + gutter.set_manual_dismiss(false); + let mut progress_action = Slider::new(renderer_cid, Opcode::Gutter.to_u32().unwrap(), + 0, 100, 1, Some("%"), 0, true, true + ); + let mut last_percentage = 0; + let mut start_work: u32 = 0; + let mut end_work: u32 = 100; + let mut renderer_modal = + Modal::new( + gam::SHARED_MODAL_NAME, + ActionType::TextEntry(text_action), + Some("Placeholder"), + None, + GlyphStyle::Regular, + 8 + ); + renderer_modal.spawn_helper(modals_sid, renderer_modal.sid, + Opcode::ModalRedraw.to_u32().unwrap(), + Opcode::ModalKeypress.to_u32().unwrap(), + Opcode::ModalDrop.to_u32().unwrap(), + ); if cfg!(feature = "ux_tests") { tt.sleep_ms(1000).unwrap(); @@ -441,147 +115,105 @@ fn xmain() -> ! { let mut msg = xous::receive_message(modals_sid).unwrap(); log::debug!("message: {:?}", msg); match FromPrimitive::from_usize(msg.body.id()) { + // ------------------ EXTERNAL APIS -------------------- Some(Opcode::GetMutex) => msg_blocking_scalar_unpack!(msg, t0, t1, t2, t3, { let incoming_token = [t0 as u32, t1 as u32, t2 as u32, t3 as u32]; - if let Some(token) = token_lock { - if token == incoming_token { - xous::return_scalar(msg.sender, 1).unwrap(); - } else { - work_queue.push((msg.sender, incoming_token)); - } - } else { + if token_lock.is_none() { token_lock = Some(incoming_token); xous::return_scalar(msg.sender, 1).unwrap(); + } else { + work_queue.push((msg.sender, incoming_token)); } }), Some(Opcode::PromptWithFixedResponse) => { - let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; - let spec = buffer.to_original::().unwrap(); - if spec.token != token_lock.unwrap_or(default_nonce) { - log::warn!("Attempt to access modals without a mutex lock. Ignoring."); - buffer.replace(ItemName::new("internal error")).unwrap(); - continue; - } - *op.lock().unwrap() = RendererState::RunRadio(spec); + let spec = { + let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let spec = buffer.to_original::().unwrap(); + if spec.token != token_lock.unwrap_or(default_nonce) { + log::warn!("Attempt to access modals without a mutex lock. Ignoring."); + buffer.replace(ItemName::new("internal error")).unwrap(); + continue; + } + spec + }; + op = RendererState::RunRadio(spec); + dr = Some(msg); send_message( renderer_cid, - Message::new_scalar(RendererOp::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't initiate UX op"); - loop { - match *op.lock().unwrap() { - RendererState::RunRadio(_) => (), - RendererState::ResponseRadio(item) => { - buffer.replace(item).unwrap(); - token_lock = next_lock(&mut work_queue); - break; - }, - _ => { - log::error!("Illegal state transition in renderer"); - panic!("Illegal state transition in renderer"); - } - } - tt.sleep_ms(100).unwrap(); // don't put the idle in the match/lock(), it'll prevent the other thread from running! - } }, Some(Opcode::PromptWithMultiResponse) => { - let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; - let spec = buffer.to_original::().unwrap(); - if spec.token != token_lock.unwrap_or(default_nonce) { - log::warn!("Attempt to access modals without a mutex lock. Ignoring."); - buffer.replace(CheckBoxPayload::new()).unwrap(); - continue; - } - *op.lock().unwrap() = RendererState::RunCheckBox(spec); + let spec = { + let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let spec = buffer.to_original::().unwrap(); + if spec.token != token_lock.unwrap_or(default_nonce) { + log::warn!("Attempt to access modals without a mutex lock. Ignoring."); + buffer.replace(CheckBoxPayload::new()).unwrap(); + continue; + } + spec + }; + op = RendererState::RunCheckBox(spec); + dr = Some(msg); send_message( renderer_cid, - Message::new_scalar(RendererOp::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't initiate UX op"); - loop { - match *op.lock().unwrap() { - RendererState::RunCheckBox(_) => (), - RendererState::ResponseCheckBox(items) => { - buffer.replace(items).unwrap(); - token_lock = next_lock(&mut work_queue); - break; - }, - _ => { - log::error!("Illegal state transition in renderer"); - panic!("Illegal state transition in renderer"); - } - } - tt.sleep_ms(100).unwrap(); // don't put the idle in the match/lock(), it'll prevent the other thread from running! - } }, Some(Opcode::PromptWithTextResponse) => { - let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; - let spec = buffer.to_original::().unwrap(); - if spec.token != token_lock.unwrap_or(default_nonce) { - log::warn!("Attempt to access modals without a mutex lock. Ignoring."); - buffer.replace(TextEntryPayload::new()).unwrap(); - continue; - } - *op.lock().unwrap() = RendererState::RunText(spec); + let spec = { + let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let spec = buffer.to_original::().unwrap(); + if spec.token != token_lock.unwrap_or(default_nonce) { + log::warn!("Attempt to access modals without a mutex lock. Ignoring."); + buffer.replace(TextEntryPayload::new()).unwrap(); + continue; + } + spec + }; + op = RendererState::RunText(spec); + dr = Some(msg); send_message( renderer_cid, - Message::new_scalar(RendererOp::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't initiate UX op"); - loop { - match *op.lock().unwrap() { - RendererState::RunText(_) => (), - RendererState::ResponseText(text) => { - buffer.replace(text).unwrap(); - token_lock = next_lock(&mut work_queue); - break; - }, - _ => { - log::error!("Illegal state transition in renderer"); - panic!("Illegal state transition in renderer"); - } - } - tt.sleep_ms(100).unwrap(); // don't put the idle in the match/lock(), it'll prevent the other thread from running! - } }, Some(Opcode::Notification) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let spec = buffer.to_original::().unwrap(); + let spec = { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + buffer.to_original::().unwrap() + }; if spec.token != token_lock.unwrap_or(default_nonce) { log::warn!("Attempt to access modals without a mutex lock. Ignoring."); continue; } - *op.lock().unwrap() = RendererState::RunNotification(spec); + op = RendererState::RunNotification(spec); + dr = Some(msg); send_message( renderer_cid, - Message::new_scalar(RendererOp::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't initiate UX op"); - loop { - match *op.lock().unwrap() { - RendererState::RunNotification(_) => (), - RendererState::None => {token_lock = next_lock(&mut work_queue); break}, - _ => { - log::error!("Illegal state transition in renderer"); - panic!("Illegal state transition in renderer"); - } - } - tt.sleep_ms(100).unwrap(); // don't put the idle in the match/lock(), it'll prevent the other thread from running! - } }, Some(Opcode::StartProgress) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let spec = buffer.to_original::().unwrap(); + let spec = { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + buffer.to_original::().unwrap() + }; if spec.token != token_lock.unwrap_or(default_nonce) { log::warn!("Attempt to access modals without a mutex lock. Ignoring."); continue; } - *op.lock().unwrap() = RendererState::RunProgress(spec); + op = RendererState::RunProgress(spec); send_message( renderer_cid, - Message::new_scalar(RendererOp::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't initiate UX op"); }, Some(Opcode::UpdateProgress) => msg_scalar_unpack!(msg, current, _, _, _, { send_message( renderer_cid, - Message::new_scalar(RendererOp::UpdateProgress.to_usize().unwrap(), current, 0, 0, 0) + Message::new_scalar(Opcode::DoUpdateProgress.to_usize().unwrap(), current, 0, 0, 0) ).expect("couldn't update progress bar"); }), Some(Opcode::StopProgress) => msg_scalar_unpack!(msg, t0, t1, t2, t3, { @@ -592,31 +224,31 @@ fn xmain() -> ! { } send_message( renderer_cid, - Message::new_scalar(RendererOp::FinishProgress.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::FinishProgress.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't update progress bar"); - token_lock = next_lock(&mut work_queue); }), Some(Opcode::AddModalItem) => { let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let manageditem = buffer.to_original::().unwrap(); if manageditem.token != token_lock.unwrap_or(default_nonce) { - log::warn!("Attempt to access modals without a mutex lock. Ignoring."); + log::warn!("Attempt to access modals without a mutex lock. Ignoring. got: {:x?} have: {:x?}", manageditem.token, token_lock); continue; } - let fwd_buf = Buffer::into_buf(manageditem.item).unwrap(); - fwd_buf.lend(renderer_cid, RendererOp::AddModalItem.to_u32().unwrap()).expect("couldn't add item"); + fixed_items.push(manageditem.item); } Some(Opcode::DynamicNotification) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let spec = buffer.to_original::().unwrap(); + let spec = { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + buffer.to_original::().unwrap() + }; if spec.token != token_lock.unwrap_or(default_nonce) { log::warn!("Attempt to access modals without a mutex lock. Ignoring."); continue; } - *op.lock().unwrap() = RendererState::RunDynamicNotification(spec); + op = RendererState::RunDynamicNotification(spec); send_message( renderer_cid, - Message::new_scalar(RendererOp::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::InitiateOp.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't initiate UX op"); }, Some(Opcode::UpdateDynamicNotification) => { @@ -626,10 +258,10 @@ fn xmain() -> ! { log::warn!("Attempt to access modals without a mutex lock. Ignoring."); continue; } - *op.lock().unwrap() = RendererState::RunDynamicNotification(spec); + op = RendererState::RunDynamicNotification(spec); send_message( renderer_cid, - Message::new_scalar(RendererOp::UpdateDynamicNotification.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::DoUpdateDynamicNotification.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't initiate UX op"); }, Some(Opcode::CloseDynamicNotification) => msg_scalar_unpack!(msg, t0, t1, t2, t3, { @@ -640,10 +272,319 @@ fn xmain() -> ! { } send_message( renderer_cid, - Message::new_scalar(RendererOp::CloseDynamicNotification.to_usize().unwrap(), 0, 0, 0, 0) + Message::new_scalar(Opcode::DoCloseDynamicNotification.to_usize().unwrap(), 0, 0, 0, 0) ).expect("couldn't close dynamic notification"); - token_lock = next_lock(&mut work_queue); }), + + // ------------------ INTERNAL APIS -------------------- + Some(Opcode::InitiateOp) => { + log::debug!("InitiateOp called"); + match op { + RendererState::RunText(config) => { + log::debug!("initiating text entry modal"); + #[cfg(feature="tts")] + tts.tts_simple(config.prompt.as_str().unwrap()).unwrap(); + renderer_modal.modify( + Some(ActionType::TextEntry(text_action)), + Some(config.prompt.as_str().unwrap()), false, + None, true, None + ); + renderer_modal.activate(); + log::debug!("should be active!"); + }, + RendererState::RunNotification(config) => { + #[cfg(feature="tts")] + tts.tts_simple(config.message.as_str().unwrap()).unwrap(); + renderer_modal.modify( + Some(ActionType::Notification(notification)), + Some(config.message.as_str().unwrap()), false, + None, true, None + ); + renderer_modal.activate(); + }, + RendererState::RunProgress(config) => { + start_work = config.start_work; + end_work = config.end_work; + last_percentage = compute_checked_percentage( + config.current_work, start_work, end_work); + log::debug!("init percentage: {}, current: {}, start: {}, end: {}", last_percentage, config.current_work, start_work, end_work); + progress_action.set_state(last_percentage); + #[cfg(feature="tts")] + tts.tts_simple(config.title.as_str().unwrap()).unwrap(); + renderer_modal.modify( + Some(ActionType::Slider(progress_action)), + Some(config.title.as_str().unwrap()), false, + None, true, None + ); + renderer_modal.activate(); + }, + RendererState::RunRadio(config) => { + let mut radiobuttons = gam::modal::RadioButtons::new( + renderer_cid, + Opcode::RadioReturn.to_u32().unwrap() + ); + for item in fixed_items.iter() { + radiobuttons.add_item(*item); + } + fixed_items.clear(); + #[cfg(feature="tts")] + { + tts.tts_blocking(t!("modals.radiobutton", xous::LANG)).unwrap(); + tts.tts_blocking(config.prompt.as_str().unwrap()).unwrap(); + } + renderer_modal.modify( + Some(ActionType::RadioButtons(radiobuttons)), + Some(config.prompt.as_str().unwrap()), false, + None, true, None + ); + renderer_modal.activate(); + }, + RendererState::RunCheckBox(config) => { + let mut checkbox = gam::modal::CheckBoxes::new( + renderer_cid, + Opcode::CheckBoxReturn.to_u32().unwrap() + ); + for item in fixed_items.iter() { + checkbox.add_item(*item); + } + fixed_items.clear(); + #[cfg(feature="tts")] + { + tts.tts_blocking(t!("modals.checkbox", xous::LANG)).unwrap(); + tts.tts_blocking(config.prompt.as_str().unwrap()).unwrap(); + } + renderer_modal.modify( + Some(ActionType::CheckBoxes(checkbox)), + Some(config.prompt.as_str().unwrap()), false, + None, true, None + ); + renderer_modal.activate(); + }, + RendererState::RunDynamicNotification(config) => { + let mut top_text = String::new(); + if let Some(title) = config.title { + #[cfg(feature="tts")] + tts.tts_simple(title.as_str().unwrap()).unwrap(); + top_text.push_str(title.as_str().unwrap()); + } + let mut bot_text = String::new(); + if let Some(text) = config.text { + #[cfg(feature="tts")] + tts.tts_simple(text.as_str().unwrap()).unwrap(); + bot_text.push_str(text.as_str().unwrap()); + } + renderer_modal.modify( + Some(ActionType::Notification(gutter)), + Some(&top_text), config.title.is_none(), + Some(&bot_text), config.text.is_none(), + None + ); + renderer_modal.activate(); + }, + RendererState::None => { + log::error!("Operation initiated with no argument specified. Ignoring request."); + continue; + } + } + }, + Some(Opcode::DoUpdateProgress) => msg_scalar_unpack!(msg, current, _, _, _, { + let new_percentage = compute_checked_percentage( + current as u32, start_work, end_work); + log::trace!("percentage: {}, current: {}, start: {}, end: {}", new_percentage, current, start_work, end_work); + if new_percentage != last_percentage { + last_percentage = new_percentage; + progress_action.set_state(last_percentage); + #[cfg(feature="tts")] + { + if tt.elapsed_ms() - last_tick > TICK_INTERVAL { + tts.tts_blocking(t!("progress.increment", xous::LANG)).unwrap(); + last_tick = tt.elapsed_ms(); + } + } + renderer_modal.modify( + Some(ActionType::Slider(progress_action)), + None, false, + None, false, None + ); + renderer_modal.redraw(); + xous::yield_slice(); // give time for the GAM to redraw + } + }), + Some(Opcode::FinishProgress) => { + renderer_modal.gam.relinquish_focus().unwrap(); + op = RendererState::None; + token_lock = next_lock(&mut work_queue); + /* + if work_queue.len() > 0 { + let (unblock_pid, token) = work_queue.remove(0); + token_lock = Some(token); + xous::return_scalar(unblock_pid, 1).unwrap(); + } else { + token_lock = None; + }*/ + }, + Some(Opcode::DoUpdateDynamicNotification) => { + match op { + RendererState::RunDynamicNotification(config) => { + let mut top_text = String::new(); + if let Some(title) = config.title { + top_text.push_str(title.as_str().unwrap()); + } + let mut bot_text = String::new(); + if let Some(text) = config.text { + bot_text.push_str(text.as_str().unwrap()); + } + renderer_modal.modify( + None, + Some(&top_text), config.title.is_none(), + Some(&bot_text), config.text.is_none(), + None + ); + renderer_modal.redraw(); + } + _ => { + log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + } + } + }, + Some(Opcode::DoCloseDynamicNotification) => { + renderer_modal.gam.relinquish_focus().unwrap(); + op = RendererState::None; + token_lock = next_lock(&mut work_queue); + }, + Some(Opcode::TextEntryReturn) => { + match op { + RendererState::RunText(config) => { + log::trace!("validating text entry modal"); + let buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let text = buf.to_original::().unwrap(); + if let Some(validator_sid) = config.validator { + let cid = xous::connect(SID::from_array(validator_sid)).unwrap(); + let validation = Validation { + text, + opcode: config.validator_op, + }; + let mut buf = Buffer::into_buf(validation).expect("couldn't convert validator structure"); + buf.lend_mut(cid, ValidationOp::Validate.to_u32().unwrap()).expect("validation call failed"); + let response = buf.to_original::>, _>().expect("couldn't unpack validation response"); + unsafe{xous::disconnect(cid).unwrap();} + if let Some(err) = response { + // try again + renderer_modal.modify( + Some(ActionType::TextEntry(text_action)), + Some(config.prompt.as_str().unwrap()), false, + Some(err.as_str().unwrap()), false, None + ); + renderer_modal.activate(); + } else { + if let Some(mut origin) = dr.take() { + let mut response = unsafe { Buffer::from_memory_message_mut(origin.body.memory_message_mut().unwrap()) }; + response.replace(text).unwrap(); + op = RendererState::None; + } else { + log::error!("Ux routine returned but no origin was recorded"); + panic!("Ux routine returned but no origin was recorded"); + } + token_lock = next_lock(&mut work_queue); + } + } else { + if let Some(mut origin) = dr.take() { + let mut response = unsafe { Buffer::from_memory_message_mut(origin.body.memory_message_mut().unwrap()) }; + response.replace(text).unwrap(); + op = RendererState::None; + } else { + log::error!("Ux routine returned but no origin was recorded"); + panic!("Ux routine returned but no origin was recorded"); + } + token_lock = next_lock(&mut work_queue); + } + } + RendererState::None => log::warn!("Text entry detected a fat finger event, ignoring."), + _ => { + log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + } + } + } + Some(Opcode::NotificationReturn) => { + match op { + RendererState::RunNotification(_) => { + op = RendererState::None; + dr.take(); // unblocks the caller, but without any response data + token_lock = next_lock(&mut work_queue); + }, + RendererState::None => log::warn!("Notification detected a fat finger event, ignoring."), + _ => { + log::error!("UX return opcode does not match our current operation in flight: {:?}", op); + panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + } + } + }, + Some(Opcode::Gutter) => { + log::info!("gutter op, doing nothing"); + }, + Some(Opcode::RadioReturn) => { + match op { + RendererState::RunRadio(_config) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let item = buffer.to_original::().unwrap(); + if let Some(mut origin) = dr.take() { + let mut response = unsafe { Buffer::from_memory_message_mut(origin.body.memory_message_mut().unwrap()) }; + response.replace(item).unwrap(); + op = RendererState::None; + } else { + log::error!("Ux routine returned but no origin was recorded"); + panic!("Ux routine returned but no origin was recorded"); + } + token_lock = next_lock(&mut work_queue); + } + RendererState::None => log::warn!("Radio buttons detected a fat finger event, ignoring."), + _ => { + log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + } + } + } + Some(Opcode::CheckBoxReturn) => { + match op { + RendererState::RunCheckBox(_config) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let item = buffer.to_original::().unwrap(); + if let Some(mut origin) = dr.take() { + let mut response = unsafe { Buffer::from_memory_message_mut(origin.body.memory_message_mut().unwrap()) }; + response.replace(item).unwrap(); + op = RendererState::None; + } else { + log::error!("Ux routine returned but no origin was recorded"); + panic!("Ux routine returned but no origin was recorded"); + } + token_lock = next_lock(&mut work_queue); + } + RendererState::None => log::warn!("Check boxes detected a fat finger event, ignoring."), + _ => { + log::error!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + panic!("UX return opcode does not match our current operation in flight. This is a serious internal error."); + } + } + } + Some(Opcode::ModalRedraw) => { + renderer_modal.redraw(); + }, + Some(Opcode::ModalKeypress) => msg_scalar_unpack!(msg, k1, k2, k3, k4, { + let keys = [ + if let Some(a) = core::char::from_u32(k1 as u32) {a} else {'\u{0000}'}, + if let Some(a) = core::char::from_u32(k2 as u32) {a} else {'\u{0000}'}, + if let Some(a) = core::char::from_u32(k3 as u32) {a} else {'\u{0000}'}, + if let Some(a) = core::char::from_u32(k4 as u32) {a} else {'\u{0000}'}, + ]; + renderer_modal.key_event(keys); + }), + Some(Opcode::ModalDrop) => { // this guy should never quit, it's a core OS service + panic!("Password modal for PDDB quit unexpectedly"); + }, + + Some(Opcode::Quit) => { log::warn!("Shared modal UX handler exiting."); break @@ -651,14 +592,10 @@ fn xmain() -> ! { None => { log::error!("couldn't convert opcode"); } - } } // clean up our program log::trace!("main loop exit, destroying servers"); - send_message(renderer_cid, Message::new_blocking_scalar(RendererOp::Quit.to_usize().unwrap(), 0, 0, 0, 0)).unwrap(); - unsafe{xous::disconnect(renderer_cid).unwrap()}; - xous::destroy_server(renderer_sid).unwrap(); xns.unregister_server(modals_sid).unwrap(); xous::destroy_server(modals_sid).unwrap(); log::trace!("quitting"); @@ -682,7 +619,14 @@ fn compute_checked_percentage(current: u32, start: u32, end: u32) -> u32 { fn next_lock(work_queue: &mut Vec::<(xous::MessageSender, [u32; 4])>) -> Option<[u32; 4]> { if work_queue.len() > 0 { + /* + log::debug!("pending:"); + for (pid, tok) in work_queue.iter() { + log::debug!("pid: {:x?}, tok: {:x?}", pid, tok); + } + */ let (unblock_pid, token) = work_queue.remove(0); + log::debug!("next token: {:x?}", token); xous::return_scalar(unblock_pid, 1).unwrap(); Some(token) } else { diff --git a/services/modals/src/tests.rs b/services/modals/src/tests.rs index edbffa562..594772760 100644 --- a/services/modals/src/tests.rs +++ b/services/modals/src/tests.rs @@ -38,7 +38,7 @@ pub(crate) fn spawn_test() { // The start and end items are deliberately structured to be not zero-indexed; the use of PDDB_LOC is just a // convenient global constant. modals.start_progress("Progress Quest", xous::PDDB_LOC, xous::PDDB_LOC + 64*1024*128, xous::PDDB_LOC).expect("couldn't raise progress bar"); - for i in (xous::PDDB_LOC..xous::PDDB_LOC + 64*1024*128).step_by(64*1024) { + for i in (xous::PDDB_LOC..xous::PDDB_LOC + 64*1024*128).step_by(64*1024*16) { modals.update_progress(i).expect("couldn't update progress bar"); tt.sleep_ms(100).unwrap(); }