diff --git a/services/shellchat/src/cmds.rs b/services/shellchat/src/cmds.rs
index b21da8449..0f54633cc 100644
--- a/services/shellchat/src/cmds.rs
+++ b/services/shellchat/src/cmds.rs
@@ -1,10 +1,15 @@
-use xous::String;
+use xous::{String, MessageEnvelope};
use core::fmt::Write;
/////////////////////////// Common items to all commands
pub trait ShellCmdApi<'a> {
// user implemented:
// called to process the command with the remainder of the string attached
fn process(&mut self, args: String::<1024>, env: &mut CommonEnv) -> Result>, xous::Error>;
+ // called to process incoming messages that may have been origniated by the most recently issued command
+ fn callback(&mut self, msg: &MessageEnvelope, _env: &mut CommonEnv) -> Result >, xous::Error> {
+ log::info!("SHCH: received unhandled message {:?}", msg);
+ Ok(None)
+ }
// created with cmd_api! macro
// checks if the command matches the current verb in question
@@ -28,6 +33,7 @@ macro_rules! cmd_api {
};
}
+
/////////////////////////// Command shell integration
#[derive(Debug)]
pub struct CommonEnv {
@@ -55,14 +61,17 @@ mod echo; use echo::*;
mod test; use test::*;
mod sleep; use sleep::*;
mod sensors; use sensors::*;
+mod callback; use callback::*;
#[derive(Debug)]
pub struct CmdEnv {
common_env: CommonEnv,
+ lastverb: String::<256>,
///// 2. declare storage for your command here.
test_cmd: Test,
sleep_cmd: Sleep,
sensors_cmd: Sensors,
+ callback_cmd: CallBack,
}
impl CmdEnv {
pub fn new(gam: xous::CID) -> CmdEnv {
@@ -74,14 +83,16 @@ impl CmdEnv {
ticktimer: xous::connect(ticktimer_server_id).unwrap(),
gam,
},
+ lastverb: String::<256>::new(),
///// 3. initialize your storage, by calling new()
test_cmd: Test::new(),
sleep_cmd: Sleep::new(),
sensors_cmd: Sensors::new(),
+ callback_cmd: CallBack::new(),
}
}
- pub fn dispatch(&mut self, cmdline: &mut String::<1024>) -> Result >, xous::Error> {
+ pub fn dispatch(&mut self, maybe_cmdline: Option<&mut String::<1024>>, maybe_callback: Option<&MessageEnvelope>) -> Result >, xous::Error> {
let mut ret = String::<1024>::new();
let mut echo_cmd = Echo {}; // this command has no persistent storage, so we can "create" it every time we call dispatch (but it's a zero-cost absraction so this doesn't actually create any instructions)
@@ -91,38 +102,59 @@ impl CmdEnv {
&mut self.test_cmd,
&mut self.sleep_cmd,
&mut self.sensors_cmd,
+ &mut self.callback_cmd,
];
- let maybe_verb = tokenize(cmdline);
+ if let Some(cmdline) = maybe_cmdline {
+ let maybe_verb = tokenize(cmdline);
- let mut cmd_ret: Result >, xous::Error> = Ok(None);
- if let Some(verb_string) = maybe_verb {
- let verb = verb_string.to_str();
+ let mut cmd_ret: Result >, xous::Error> = Ok(None);
+ if let Some(verb_string) = maybe_verb {
+ let verb = verb_string.to_str();
- // search through the list of commands linearly until one matches,
- // then run it.
- let mut match_found = false;
- for cmd in commands.iter_mut() {
- if cmd.matches(verb) {
- match_found = true;
- cmd_ret = cmd.process(*cmdline, &mut self.common_env);
- };
- }
-
- // if none match, create a list of available commands
- if !match_found {
- let mut first = true;
- write!(ret, "Commands: ").unwrap();
- for cmd in commands.iter() {
- if !first {
- ret.append(", ")?;
- }
- ret.append(cmd.verb())?;
- first = false;
+ // search through the list of commands linearly until one matches,
+ // then run it.
+ let mut match_found = false;
+ for cmd in commands.iter_mut() {
+ if cmd.matches(verb) {
+ match_found = true;
+ cmd_ret = cmd.process(*cmdline, &mut self.common_env);
+ self.lastverb.clear();
+ write!(self.lastverb, "{}", verb).expect("SHCH: couldn't record last verb");
+ };
+ }
+
+ // if none match, create a list of available commands
+ if !match_found {
+ let mut first = true;
+ write!(ret, "Commands: ").unwrap();
+ for cmd in commands.iter() {
+ if !first {
+ ret.append(", ")?;
+ }
+ ret.append(cmd.verb())?;
+ first = false;
+ }
+ Ok(Some(ret))
+ } else {
+ cmd_ret
}
- Ok(Some(ret))
} else {
+ Ok(None)
+ }
+ } else if let Some(callback) = maybe_callback {
+ let mut cmd_ret: Result >, xous::Error> = Ok(None);
+ if self.lastverb.len() > 0 {
+ let verb = self.lastverb.to_str();
+ for cmd in commands.iter_mut() {
+ if cmd.matches(verb) {
+ cmd_ret = cmd.callback(callback, &mut self.common_env);
+ break;
+ };
+ }
cmd_ret
+ } else {
+ Ok(None)
}
} else {
Ok(None)
diff --git a/services/shellchat/src/main.rs b/services/shellchat/src/main.rs
index fc52792a2..534c7d5b1 100644
--- a/services/shellchat/src/main.rs
+++ b/services/shellchat/src/main.rs
@@ -1,7 +1,7 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
-use log::{error, info};
+use log::info;
use core::fmt::Write;
use core::convert::TryFrom;
@@ -12,6 +12,7 @@ use core::pin::Pin;
use ime_plugin_api::{ImeFrontEndApi, ImeFrontEnd};
use graphics_server::{Gid, Point, Rectangle, TextBounds, TextView, DrawStyle, GlyphStyle, PixelColor};
+use xous::MessageEnvelope;
use heapless::spsc::Queue;
use heapless::consts::U16;
@@ -32,7 +33,8 @@ struct Repl {
// optional structures that indicate new input to the Repl loop per iteration
// an input string
input: Option>,
- // examples of future inputs: returned values via other services
+ // messages from other servers
+ msg: Option,
// record our input history
history: Queue,
@@ -57,6 +59,7 @@ impl Repl{
let screensize = gam::get_canvas_bounds(gam_conn, content).expect("SHCH: couldn't get dimensions of content canvas");
Repl {
input: None,
+ msg: None,
history: Queue::new(),
content,
gam: gam_conn,
@@ -80,6 +83,10 @@ impl Repl{
Ok(())
}
+ fn msg(&mut self, message: MessageEnvelope) {
+ self.msg = Some(message);
+ }
+
fn circular_push(&mut self, item: History) {
if self.history.len() == self.history.capacity() {
self.history.dequeue().expect("SHCH: couldn't dequeue historye");
@@ -108,7 +115,17 @@ impl Repl{
// take the input and pass it on to the various command parsers, and attach result
if let Some(mut local) = self.input {
- if let Some(res) = self.env.dispatch(&mut local).expect("SHCH: command dispatch failed") {
+ if let Some(res) = self.env.dispatch(Some(&mut local), None).expect("SHCH: command dispatch failed") {
+ let mut response = xous::String::<1024>::new();
+ write!(response, "{}", res).expect("SHCH: can't copy result to history");
+ let output_history = History {
+ text: response,
+ is_input: false
+ };
+ self.circular_push(output_history);
+ }
+ } else if let Some(msg) = &self.msg {
+ if let Some(res) = self.env.dispatch(None, Some(msg)).expect("SCHC: callback failed") {
let mut response = xous::String::<1024>::new();
write!(response, "{}", res).expect("SHCH: can't copy result to history");
let output_history = History {
@@ -121,6 +138,7 @@ impl Repl{
// clear all the inputs to the loop, so we don't process them twice
self.input = None;
+ self.msg = None;
// redraw UI now that we've responded
self.redraw().expect("SHCH: can't redraw");
@@ -233,7 +251,8 @@ fn xmain() -> ! {
}
}
} else {
- error!("SHCH: couldn't convert message");
+ repl.msg(envelope);
+ update_repl = true;
}
if update_repl {