diff --git a/Cargo.lock b/Cargo.lock index b604320f9..5e7a51471 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2210,6 +2210,30 @@ dependencies = [ "xous-ipc 0.9.13 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "mtxcli" +version = "0.1.0" +dependencies = [ + "codec", + "com", + "content-plugin-api", + "gam", + "graphics-server", + "ime-plugin-api", + "ime-plugin-shell", + "llio", + "locales", + "log", + "num-derive", + "num-traits", + "trng", + "xous 0.9.13 (registry+https://github.com/rust-lang/crates.io-index)", + "xous-api-log", + "xous-api-names", + "xous-api-ticktimer", + "xous-ipc 0.9.13 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "nb" version = "0.1.3" diff --git a/Cargo.toml b/Cargo.toml index 46b1bdf49..7bece7bb8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,6 +29,7 @@ default-members = [ "services/dns", "services/modals", "services/usb-device-xous", + "apps/mtxcli", ] members = [ "xous-ipc", @@ -72,6 +73,7 @@ members = [ "services/modals", "apps/ball", "apps/hello", + "apps/mtxcli", "apps/repl", "apps/vault", "apps/vault/tools/vaultbackup-rs", @@ -156,4 +158,4 @@ rev="36e419d05ce1d6957a3cc25092f2d68feba8e9a3" # use the commitref because we're #branch="0.16.20-cleanup" # [patch.crates-io.xous] -# path = "./xous-rs" \ No newline at end of file +# path = "./xous-rs" diff --git a/apps/manifest.json b/apps/manifest.json index 0e117f2bb..faa8b6156 100644 --- a/apps/manifest.json +++ b/apps/manifest.json @@ -43,5 +43,16 @@ "en-tts": "Basic REPL demo" } } + }, + "mtxcli": { + "context_name": "Matrix chat", + "menu_name": { + "appmenu.repl": { + "en": "Matrix chat", + "ja": "シンプルなMATRIXデモ", + "zh": "基本 MATRIX 演示", + "en-tts": "Basic MATRIX demo" + } + } } } diff --git a/apps/mtxcli/Cargo.toml b/apps/mtxcli/Cargo.toml new file mode 100644 index 000000000..8cc9ba0dc --- /dev/null +++ b/apps/mtxcli/Cargo.toml @@ -0,0 +1,30 @@ +[package] +name = "mtxcli" +version = "0.1.0" +authors = ["bunnie "] +edition = "2018" +description = "Matrix chat" + +# Dependency versions enforced by Cargo.lock. +[dependencies] +log = "0.4.14" +num-derive = {version = "0.3.3", default-features = false} +num-traits = {version = "0.2.14", default-features = false} +xous = "0.9.13" +xous-ipc = "0.9.13" +log-server = { package = "xous-api-log", version = "0.1.7" } +ticktimer-server = { package = "xous-api-ticktimer", version = "0.9.5" } +xous-names = { package = "xous-api-names", version = "0.9.8" } +gam = {path = "../../services/gam" } +graphics-server = {path = "../../services/graphics-server" } +trng = {path = "../../services/trng"} +locales = {path = "../../locales"} +ime-plugin-api = {path = "../../services/ime-plugin-api"} +ime-plugin-shell = {path = "../../services/ime-plugin-shell"} +content-plugin-api = {path = "../../services/content-plugin-api"} # all content canvas providers must provide this API +com = {path = "../../services/com"} +llio = {path = "../../services/llio"} +codec = {path = "../../services/codec"} + +[features] +default = [] diff --git a/apps/mtxcli/README.md b/apps/mtxcli/README.md new file mode 100644 index 000000000..358e6c0fd --- /dev/null +++ b/apps/mtxcli/README.md @@ -0,0 +1,68 @@ +# MTXCLI + +This is a new Matrix chat application which will be derived from REPL. + +# Inherited from REPL + +A simple demo application that provides a bare-bones REPL framework. +## Copying This Demo to a New App + +1. Copy this demo application, and rename the relevant structures in its `Cargo.toml` and `main.rs`. +2. Add it to the Workspace `default-members` and `members` arrays by editing `./Cargo.toml` +3. Edit the `manifest.json` file as documented in its [README](../README.md) +4. Build using `cargo xtask app-image you_new_app` to create a flashable Xous image with your app in it. +## Details + +![screenshot](repl_screenshot.png) + +`repl` is a baseline demo application for Xous. It uses a chat-client +style interface (stacking bubbles of text, with user input right-aligned +and shell feedback left-aligned) to facilitate interactions. + +It implements the basic envisioned structure of a Xous application, namely: + + - Text input comes via the `ime-frontend` + - Graphical output is rendered via the `gam` + +[Push Events and Listeners](https://github.com/betrusted-io/xous-core/wiki/Push-Events-and-Listeners) provides an overview of the flow of +messages between an Xous application and the Xous Services. + +The one demo command provisioned in the `repl` app plays a tone via +the `codec` service. This was chosen because it is about one of the most complicated +and comprehensive things you can do in the `repl` environment, as it requires +real-time callbacks to fill the audio buffer with new samples. If you have +specific questions about how the callbacks work, we encourage you to open +an issue in this repo and ask your question. Your questions will help us +direct effort toward building the documentation base. + +To make your own command, copy the `audio.rs` template +in the `apps/repl/src/cmds/` directory, or use this very basic `echo` +template: + +```Rust +use crate::{ShellCmdApi, CommonEnv}; +use xous_ipc::String; + +#[derive(Debug)] +pub struct Echo { +} + +impl<'a> ShellCmdApi<'a> for Echo { + cmd_api!(echo); // inserts boilerplate for command API + + fn process(&mut self, args: String::<1024>, _env: &mut CommonEnv) -> Result>, xous::Error> { + Ok(Some(rest)) + } +} +``` + +The "verb" is the name of your command, and it is the argument to the `cmd_api!()` macro. + +`process()` is your "main" function, and `args` is a string which contains the +rest of the line that was typed into the chat, minus the verb used to identify +your command (e.g. the arguments, but not tokenized or parsed in +any way). `env` contains some items in a common environment, for example, connections +to the GAM, LLIO server or other resources required by your implementation. + +Once you've added your command to the directory, go to the `cmds.rs` file, and follow +the four-step instructions embedded within the file, starting around line 40. diff --git a/apps/mtxcli/locales/i18n.json b/apps/mtxcli/locales/i18n.json new file mode 100644 index 000000000..766249fda --- /dev/null +++ b/apps/mtxcli/locales/i18n.json @@ -0,0 +1,32 @@ +{ + "mtxcli.greeting": { + "en": "Welcome to the simple MTXCLI demo.", + "ja": "シンプルなMTXCLIデモへようこそ", + "zh": "简单的 mtxcli 演示活动", + "en-tts": "Welcome to the simple MTXCLI demo." + }, + "mtxcli.audio.start": { + "en": "tone started...", + "ja": "トーン開始…", + "zh": "哔声开始...", + "en-tts": "tone started..." + }, + "mtxcli.audio.help": { + "en": "audio [tone [freq [duration]]]", + "ja": "オーディオ [ トーン [ 周波数 [ 間隔 ]]]", + "zh": "audio [tone [音频 [时长]]]", + "en-tts": "audio tone, then optional frequency plus optional duration." + }, + "mtxcli.audio.completion_a": { + "en": "Playback stopped at", + "ja": "再生停止位置: ", + "zh": "播放停止在", + "en-tts": "Playback stopped at" + }, + "mtxcli.audio.completion_b": { + "en": "frames", + "ja": "フレーム", + "zh": "帧", + "en-tts": "frames" + } +} diff --git a/apps/mtxcli/mtxcli_screenshot.png b/apps/mtxcli/mtxcli_screenshot.png new file mode 100644 index 000000000..27dd23d7d Binary files /dev/null and b/apps/mtxcli/mtxcli_screenshot.png differ diff --git a/apps/mtxcli/src/cmds.rs b/apps/mtxcli/src/cmds.rs new file mode 100644 index 000000000..043febd27 --- /dev/null +++ b/apps/mtxcli/src/cmds.rs @@ -0,0 +1,219 @@ +use xous::{MessageEnvelope}; +use xous_ipc::String; +use core::fmt::Write; + +use std::collections::HashMap; +/////////////////////////// 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!("received unhandled message {:?}", msg); + Ok(None) + } + + // created with cmd_api! macro + // checks if the command matches the current verb in question + fn matches(&self, verb: &str) -> bool; + // returns my verb + fn verb(&self) -> &'static str; +} +// the argument to this macro is the command verb +macro_rules! cmd_api { + ($verb:expr) => { + fn verb(&self) -> &'static str { + stringify!($verb) + } + fn matches(&self, verb: &str) -> bool { + if verb == stringify!($verb) { + true + } else { + false + } + } + }; +} + +use trng::*; +/////////////////////////// Command shell integration +#[derive(Debug)] +#[allow(dead_code)] // there's more in the envornment right now than we need for the demo +pub struct CommonEnv { + llio: llio::Llio, + com: com::Com, + codec: codec::Codec, + ticktimer: ticktimer_server::Ticktimer, + gam: gam::Gam, + cb_registrations: HashMap::>, + trng: Trng, + xns: xous_names::XousNames, +} +impl CommonEnv { + pub fn register_handler(&mut self, verb: String::<256>) -> u32 { + let mut key: u32; + loop { + key = self.trng.get_u32().unwrap(); + // reserve the bottom 1000 IDs for the main loop enums. + if !self.cb_registrations.contains_key(&key) && (key > 1000) { + break; + } + } + self.cb_registrations.insert(key, verb); + key + } +} + +/* + To add a new command: + 0. ensure that the command implements the ShellCmdApi (above) + 1. mod/use the new command + 2. create an entry for the command's storage in the CmdEnv structure + 3. initialize the persistant storage here + 4. add it to the "commands" array in the dispatch() routine below + + Side note: if your command doesn't require persistent storage, you could, + technically, generate the command dynamically every time it's called. +*/ + +///// 1. add your module here, and pull its namespace into the local crate +mod audio; use audio::*; + +pub struct CmdEnv { + common_env: CommonEnv, + lastverb: String::<256>, + ///// 2. declare storage for your command here. + audio_cmd: Audio, +} +impl CmdEnv { + pub fn new(xns: &xous_names::XousNames) -> CmdEnv { + let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer"); + log::info!("creating CommonEnv"); + let common = CommonEnv { + llio: llio::Llio::new(&xns), + com: com::Com::new(&xns).expect("could't connect to COM"), + codec: codec::Codec::new(&xns).expect("couldn't connect to CODEC"), + ticktimer, + gam: gam::Gam::new(&xns).expect("couldn't connect to GAM"), + cb_registrations: HashMap::new(), + trng: Trng::new(&xns).unwrap(), + xns: xous_names::XousNames::new().unwrap(), + }; + log::info!("done creating CommonEnv"); + CmdEnv { + common_env: common, + lastverb: String::<256>::new(), + ///// 3. initialize your storage, by calling new() + audio_cmd: Audio::new(&xns), + } + } + + 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 commands: &mut [& mut dyn ShellCmdApi] = &mut [ + ///// 4. add your command to this array, so that it can be looked up and dispatched + &mut self.audio_cmd, + ]; + + 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(); + + // 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("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 + } + } else { + Ok(None) + } + } else if let Some(callback) = maybe_callback { + let mut cmd_ret: Result>, xous::Error> = Ok(None); + // first check and see if we have a callback registration; if not, just map to the last verb + let verb = match self.common_env.cb_registrations.get(&(callback.body.id() as u32)) { + Some(verb) => { + verb.to_str() + }, + None => { + self.lastverb.to_str() + } + }; + // now dispatch + let mut verbfound = false; + for cmd in commands.iter_mut() { + if cmd.matches(verb) { + cmd_ret = cmd.callback(callback, &mut self.common_env); + verbfound = true; + break; + }; + } + if verbfound { + cmd_ret + } else { + Ok(None) + } + } else { + Ok(None) + } + } +} + +/// extract the first token, as delimited by spaces +/// modifies the incoming line by removing the token and returning the remainder +/// returns the found token +pub fn tokenize(line: &mut String::<1024>) -> Option> { + let mut token = String::<1024>::new(); + let mut retline = String::<1024>::new(); + + let lineiter = line.as_str().unwrap().chars(); + let mut foundspace = false; + let mut foundrest = false; + for ch in lineiter { + if ch != ' ' && !foundspace { + token.push(ch).unwrap(); + } else if foundspace && foundrest { + retline.push(ch).unwrap(); + } else if foundspace && ch != ' ' { + // handle case of multiple spaces in a row + foundrest = true; + retline.push(ch).unwrap(); + } else { + foundspace = true; + // consume the space + } + } + line.clear(); + write!(line, "{}", retline.as_str().unwrap()).unwrap(); + if token.len() > 0 { + Some(token) + } else { + None + } +} diff --git a/apps/mtxcli/src/cmds/audio.rs b/apps/mtxcli/src/cmds/audio.rs new file mode 100644 index 000000000..4575eb527 --- /dev/null +++ b/apps/mtxcli/src/cmds/audio.rs @@ -0,0 +1,185 @@ +use crate::{ShellCmdApi,CommonEnv}; +use xous_ipc::String; +use xous::{MessageEnvelope, Message}; +use codec::*; +use core::fmt::Write; +use locales::t; + +#[derive(Debug)] +pub struct Audio { + callback_id: Option, + callback_conn: u32, + framecount: u32, + play_sample: f32, // count of play samples generated. in f32 to avoid int<->f32 conversions + freq: f32, +} +impl Audio { + pub fn new(xns: &xous_names::XousNames) -> Self { + let callback_conn = xns.request_connection_blocking(crate::SERVER_NAME_MTXCLI).unwrap(); + Audio { + callback_id: None, + callback_conn, + framecount: 0, + play_sample: 0.0, + freq: 440.0, + } + } +} + +const STOP_ID: usize = 1; +const SAMPLE_RATE_HZ: f32 = 8000.0; +// note to self: A4 = 440.0, E4 = 329.63, C4 = 261.63 + +use std::num::ParseIntError; +/// this will parse a simple decimal into an i32, multiplied by 1000 +/// we do this because the full f32 parsing stuff is pretty heavy, some +/// 28kiB of code +#[inline(never)] +fn simple_kilofloat_parse(input: &str) -> core::result::Result { + if let Some((integer, fraction)) = input.split_once('.') { + let mut result = integer.parse::()? * 1000; + let mut significance = 100i32; + for (place, digit) in fraction.chars().enumerate() { + if place >= 3 { + break; + } + if let Some(d) = digit.to_digit(10) { + if result >= 0 { + result += (d as i32) * significance; + } else { + result -= (d as i32) * significance; + } + significance /= 10; + } else { + return "z".parse::() // you can't create a ParseIntError any other way + } + } + Ok(result) + } else { + let base = input.parse::()?; + Ok(base * 1000) + } +} + +impl<'a> ShellCmdApi<'a> for Audio { + cmd_api!(audio); + + fn process(&mut self, args: String::<1024>, env: &mut CommonEnv) -> Result>, xous::Error> { + let mut ret = String::<1024>::new(); + let helpstring = t!("mtxcli.audio.help", xous::LANG); + let mut tokens = args.as_str().unwrap().split(' '); + + if let Some(sub_cmd) = tokens.next() { + match sub_cmd { + "tone" => { + self.freq = if let Some(freq_str) = tokens.next() { + match simple_kilofloat_parse(freq_str) { + Ok(f) => (f as f32) / 1000.0, + Err(_) => 440.0, + } + } else { + 440.0 + }; + let mut duration: f32 = if let Some(duration_str) = tokens.next() { + simple_kilofloat_parse(duration_str).unwrap_or(500) as f32 / 1000.0 + } else { + 0.5 + }; + if duration > 10.0 { + duration = 10.0; // sanity check the duration so we don't go nuts + } + + env.codec.setup_8k_stream().expect("couldn't set the CODEC to expected defaults"); + env.ticktimer.sleep_ms(50).unwrap(); + + env.codec.set_speaker_volume(VolumeOps::RestoreDefault, None).unwrap(); + env.codec.set_headphone_volume(VolumeOps::RestoreDefault, None).unwrap(); + + if self.callback_id.is_none() { + let cb_id = env.register_handler(String::<256>::from_str(self.verb())); + log::trace!("hooking frame callback with ID {}", cb_id); + env.codec.hook_frame_callback(cb_id, self.callback_conn).unwrap(); // any non-handled IDs get routed to our callback port + self.callback_id = Some(cb_id); + } + + self.play_sample = 0.0; + + env.codec.resume().unwrap(); + + // kick off a thread that stops the playback, after the designated delay + std::thread::spawn({ + let cb_id = self.callback_id.unwrap().clone(); + let conn = self.callback_conn.clone(); + let duration = duration.clone(); + move || { + let ticktimer = ticktimer_server::Ticktimer::new().unwrap(); + ticktimer.sleep_ms((duration * 1000.0) as usize).unwrap(); + xous::send_message(conn, Message::new_scalar(cb_id as usize, 0, 0, 0, STOP_ID)).unwrap(); + } + }); + write!(ret, "{}", t!("mtxcli.audio.start", xous::LANG)).unwrap(); + } + _ => { + write!(ret, "{}", helpstring).unwrap(); + } + } + + } + Ok(Some(ret)) + } + + fn callback(&mut self, msg: &MessageEnvelope, env: &mut CommonEnv) -> Result>, xous::Error> { + const AMPLITUDE: f32 = 0.8; + + match &msg.body { + Message::Scalar(xous::ScalarMessage{id: _, arg1: free_play, arg2: _avail_rec, arg3: _, arg4: routing_id}) => { + if *routing_id == codec::AUDIO_CB_ROUTING_ID { + let mut frames: FrameRing = FrameRing::new(); + let frames_to_push = if frames.writeable_count() < *free_play { + frames.writeable_count() + } else { + *free_play + }; + self.framecount += frames_to_push as u32; + + log::debug!("f{} p{}", self.framecount, frames_to_push); + for _ in 0..frames_to_push { + let mut frame: [u32; codec::FIFO_DEPTH] = [ZERO_PCM as u32 | (ZERO_PCM as u32) << 16; codec::FIFO_DEPTH]; + // put the "expensive" f32 comparison outside the cosine wave table computation loop + let omega = self.freq * 2.0 * std::f32::consts::PI / SAMPLE_RATE_HZ; + for sample in frame.iter_mut() { + let raw_sine: i16 = (AMPLITUDE * f32::cos( self.play_sample * omega ) * i16::MAX as f32) as i16; + let left = raw_sine as u16; + let right = raw_sine as u16; + *sample = right as u32 | (left as u32) << 16; + self.play_sample += 1.0; + } + + frames.nq_frame(frame).unwrap(); + + } + env.codec.swap_frames(&mut frames).unwrap(); + } else if *routing_id == STOP_ID { + let mut ret = String::<1024>::new(); + env.codec.abort().unwrap(); // this should stop callbacks from occurring too. + write!(ret, "{} {} {}.", + t!("mtxcli.audio.completion_a", xous::LANG), + self.framecount, + t!("mtxcli.audio.completion_b", xous::LANG), + ).unwrap(); + self.framecount = 0; + self.play_sample = 0.0; + env.codec.power_off().unwrap(); + return Ok(Some(ret)); + } + }, + Message::Move(_mm) => { + log::error!("received memory message when not expected") + }, + _ => { + log::error!("received unknown callback type") + } + } + Ok(None) + } +} diff --git a/apps/mtxcli/src/main.rs b/apps/mtxcli/src/main.rs new file mode 100644 index 000000000..9084c32d0 --- /dev/null +++ b/apps/mtxcli/src/main.rs @@ -0,0 +1,91 @@ +#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(target_os = "none", no_main)] + +mod mtxcli; +use mtxcli::*; +mod cmds; +use cmds::*; +use num_traits::*; +use xous_ipc::Buffer; + +#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] +pub(crate) enum MtxcliOp { + /// a line of text has arrived + Line = 0, // make sure we occupy opcodes with discriminants < 1000, as the rest are used for callbacks + /// redraw our UI + Redraw, + /// change focus + ChangeFocus, + /// exit the application + Quit, +} + +// This name should be (1) unique (2) under 64 characters long and (3) ideally descriptive. +pub(crate) const SERVER_NAME_MTXCLI: &str = "_Matrix chat_"; + +fn main() -> ! { + log_server::init_wait().unwrap(); + log::set_max_level(log::LevelFilter::Info); + log::info!("my PID is {}", xous::process::id()); + + let xns = xous_names::XousNames::new().unwrap(); + // unlimited connections allowed, this is a user app and it's up to the app to decide its policy + let sid = xns.register_name(SERVER_NAME_MTXCLI, None).expect("can't register server"); + // log::trace!("registered with NS -- {:?}", sid); + + let mut mtxcli = Mtxcli::new(&xns, sid); + let mut update_mtxcli = true; + let mut was_callback = false; + let mut allow_redraw = false; + loop { + let msg = xous::receive_message(sid).unwrap(); + log::debug!("got message {:?}", msg); + match FromPrimitive::from_usize(msg.body.id()) { + Some(MtxcliOp::Line) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let s = buffer.as_flat::, _>().unwrap(); + log::trace!("mtxcli got input line: {}", s.as_str()); + mtxcli.input(s.as_str()).expect("MTXCLI couldn't accept input string"); + update_mtxcli = true; // set a flag, instead of calling here, so message can drop and calling server is released + was_callback = false; + } + Some(MtxcliOp::Redraw) => { + if allow_redraw { + mtxcli.redraw().expect("MTXCLI couldn't redraw"); + } + } + Some(MtxcliOp::ChangeFocus) => xous::msg_scalar_unpack!(msg, new_state_code, _, _, _, { + let new_state = gam::FocusState::convert_focus_change(new_state_code); + match new_state { + gam::FocusState::Background => { + allow_redraw = false; + } + gam::FocusState::Foreground => { + allow_redraw = true; + } + } + }), + Some(MtxcliOp::Quit) => { + log::error!("got Quit"); + break; + } + _ => { + log::trace!("got unknown message, treating as callback"); + mtxcli.msg(msg); + update_mtxcli = true; + was_callback = true; + } + } + if update_mtxcli { + mtxcli.update(was_callback).expect("MTXCLI had problems updating"); + update_mtxcli = false; + } + log::trace!("reached bottom of main loop"); + } + // clean up our program + log::error!("main loop exit, destroying servers"); + xns.unregister_server(sid).unwrap(); + xous::destroy_server(sid).unwrap(); + log::trace!("quitting"); + xous::terminate_process(0) +} diff --git a/apps/mtxcli/src/mtxcli.rs b/apps/mtxcli/src/mtxcli.rs new file mode 100644 index 000000000..1d9ba6134 --- /dev/null +++ b/apps/mtxcli/src/mtxcli.rs @@ -0,0 +1,215 @@ +use super::*; +use gam::UxRegistration; +use graphics_server::{Gid, Point, Rectangle, TextBounds, TextView, DrawStyle, PixelColor}; +use graphics_server::api::GlyphStyle; +use xous::MessageEnvelope; +use core::fmt::Write; +use locales::t; + +#[derive(Debug)] +struct History { + // the history record + pub text: String, + // if true, this was input from the user; if false, it's a response from the shell + pub is_input: bool, +} + +#[allow(dead_code)] +pub(crate) struct Mtxcli { + // optional structures that indicate new input to the Mtxcli loop per iteration + // an input string + input: Option, + // messages from other servers + msg: Option, + + // record our input history + history: Vec::, + history_len: usize, + content: Gid, + gam: gam::Gam, + + // variables that define our graphical attributes + screensize: Point, + bubble_width: u16, + margin: Point, // margin to edge of canvas + bubble_margin: Point, // margin of text in bubbles + bubble_radius: u16, + bubble_space: i16, // spacing between text bubbles + + // command environment + env: CmdEnv, + + // our security token for making changes to our record on the GAM + token: [u32; 4], +} +impl Mtxcli{ + pub(crate) fn new(xns: &xous_names::XousNames, sid: xous::SID) -> Self { + let gam = gam::Gam::new(xns).expect("can't connect to GAM"); + + let token = gam.register_ux(UxRegistration { + app_name: xous_ipc::String::<128>::from_str(gam::APP_NAME_MTXCLI), + ux_type: gam::UxType::Chat, + predictor: Some(xous_ipc::String::<64>::from_str(ime_plugin_shell::SERVER_NAME_IME_PLUGIN_SHELL)), + listener: sid.to_array(), // note disclosure of our SID to the GAM -- the secret is now shared with the GAM! + redraw_id: MtxcliOp::Redraw.to_u32().unwrap(), + gotinput_id: Some(MtxcliOp::Line.to_u32().unwrap()), + audioframe_id: None, + rawkeys_id: None, + focuschange_id: Some(MtxcliOp::ChangeFocus.to_u32().unwrap()), + }).expect("couldn't register Ux context for mtxcli"); + + let content = gam.request_content_canvas(token.unwrap()).expect("couldn't get content canvas"); + let screensize = gam.get_canvas_bounds(content).expect("couldn't get dimensions of content canvas"); + Mtxcli { + input: None, + msg: None, + history: vec![History{text: String::from(t!("mtxcli.greeting", xous::LANG)), is_input: false}], + history_len: 10, + content, + gam, + screensize, + bubble_width: ((screensize.x / 5) * 4) as u16, // 80% width for the text bubbles + margin: Point::new(4, 4), + bubble_margin: Point::new(4, 4), + bubble_radius: 4, + bubble_space: 4, + env: CmdEnv::new(xns), + token: token.unwrap(), + } + } + + /// accept a new input string + pub(crate) fn input(&mut self, line: &str) -> Result<(), xous::Error> { + self.input = Some(String::from(line)); + + Ok(()) + } + + pub(crate) fn msg(&mut self, message: MessageEnvelope) { + self.msg = Some(message); + } + + fn circular_push(&mut self, item: History) { + if self.history.len() >= self.history_len { + self.history.remove(0); + } + self.history.push(item); + } + + /// update the loop, in response to various inputs + pub(crate) fn update(&mut self, was_callback: bool) -> Result<(), xous::Error> { + // if we had an input string, do something + if let Some(local) = &self.input { + let input_history = History { + text: local.to_string(), + is_input: true, + }; + self.circular_push(input_history); + } + + // AT THIS POINT: if we have other inputs, update accordingly + // other inputs might be, for example, events that came in from other servers that would + // side effect our commands + + // redraw UI once upon accepting all input + if !was_callback { // don't need to redraw on a callback, save some cycles + self.redraw().expect("can't redraw"); + } + + let mut dirty = true; + // take the input and pass it on to the various command parsers, and attach result + if let Some(local) = &self.input { + if let Some(res) = self.env.dispatch(Some(&mut xous_ipc::String::<1024>::from_str(&local)), None).expect("command dispatch failed") { + let output_history = History { + text: String::from(res.as_str().unwrap_or("UTF-8 Error")), + is_input: false + }; + self.circular_push(output_history); + } else { + dirty = false; + } + } else if let Some(msg) = &self.msg { + if let Some(res) = self.env.dispatch(None, Some(msg)).expect("callback failed") { + let output_history = History { + text: String::from(res.as_str().unwrap_or("UTF-8 Error")), + is_input: false + }; + self.circular_push(output_history); + } else { + dirty = false; + } + } + + // 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 + if dirty { + self.redraw().expect("can't redraw"); + } + + Ok(()) + } + + fn clear_area(&self) { + self.gam.draw_rectangle(self.content, + Rectangle::new_with_style(Point::new(0, 0), self.screensize, + DrawStyle { + fill_color: Some(PixelColor::Light), + stroke_color: None, + stroke_width: 0 + } + )).expect("can't clear content area"); + } + pub(crate) fn redraw(&mut self) -> Result<(), xous::Error> { + self.clear_area(); + + // this defines the bottom border of the text bubbles as they stack up wards + let mut bubble_baseline = self.screensize.y - self.margin.y; + + // iterator returns from oldest to newest + // .rev() iterator is from newest to oldest + for h in self.history.iter().rev() { + let mut bubble_tv = + if h.is_input { + TextView::new(self.content, + TextBounds::GrowableFromBr( + Point::new(self.screensize.x - self.margin.x, bubble_baseline), + self.bubble_width)) + } else { + TextView::new(self.content, + TextBounds::GrowableFromBl( + Point::new(self.margin.x, bubble_baseline), + self.bubble_width)) + }; + if h.is_input { + bubble_tv.border_width = 1; + } else { + bubble_tv.border_width = 2; + } + bubble_tv.draw_border = true; + bubble_tv.clear_area = true; + bubble_tv.rounded_border = Some(self.bubble_radius); + bubble_tv.style = GlyphStyle::Regular; + bubble_tv.margin = self.bubble_margin; + bubble_tv.ellipsis = false; bubble_tv.insertion = None; + write!(bubble_tv.text, "{}", h.text.as_str()).expect("couldn't write history text to TextView"); + self.gam.post_textview(&mut bubble_tv).expect("couldn't render bubble textview"); + + if let Some(bounds) = bubble_tv.bounds_computed { + // we only subtract 1x of the margin because the bounds were computed from a "bottom right" that already counted + // the margin once. + bubble_baseline -= (bounds.br.y - bounds.tl.y) + self.bubble_space + self.bubble_margin.y; + if bubble_baseline <= 0 { + // don't draw history that overflows the top of the screen + break; + } + } else { + break; // we get None on the bounds computed if the text view fell off the top of the screen + } + } + log::trace!("mtxcli app redraw##"); + self.gam.redraw().expect("couldn't redraw screen"); + Ok(()) + } +} diff --git a/services/gam/src/lib.rs b/services/gam/src/lib.rs index c53417d7b..fddab12b4 100644 --- a/services/gam/src/lib.rs +++ b/services/gam/src/lib.rs @@ -43,6 +43,7 @@ pub const APP_NAME_SHELLCHAT: &'static str = "shellchat"; pub const APP_MENU_NAME: &'static str = "app menu"; pub const KBD_MENU_NAME: &'static str = "keyboard menu"; pub const WIFI_MENU_NAME: &'static str = "WLAN menu"; +pub const APP_NAME_MTXCLI: &'static str = "mtxcli"; /// UX context registry. Names here are authorized by the GAM to have Canvases. pub const EXPECTED_BOOT_CONTEXTS: &[&'static str] = &[ @@ -57,6 +58,7 @@ pub const EXPECTED_BOOT_CONTEXTS: &[&'static str] = &[ APP_MENU_NAME, KBD_MENU_NAME, WIFI_MENU_NAME, + APP_NAME_MTXCLI, ]; #[derive(Copy, Clone, PartialEq, Eq, Debug)]