format apps/mtxcli

somehow, this was missed.
This commit is contained in:
bunnie 2024-01-15 00:46:06 +08:00
parent 0c50581e9c
commit 536ad89010
15 changed files with 413 additions and 454 deletions

View file

@ -1,15 +1,16 @@
use xous::{MessageEnvelope, Message,StringBuffer};
use xous_ipc::String as XousString;
use core::fmt::Write;
use core::str::FromStr;
use std::collections::HashMap;
use std::fs::File;
use std::io::{Read, Write as StdWrite, Error, ErrorKind};
use std::io::{Error, ErrorKind, Read, Write as StdWrite};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH}; // to help gen_txn_id
use core::str::FromStr;
mod migrations; use migrations::run_migrations;
use xous::{Message, MessageEnvelope, StringBuffer};
use xous_ipc::String as XousString;
mod migrations;
use migrations::run_migrations;
mod url;
mod web;
@ -69,12 +70,11 @@ fn get_version(ticktimer: &ticktimer_server::Ticktimer) -> String {
let v: Vec<&str> = xous_version.split('-').collect();
if v.len() > 2 {
let n = v[1].parse::<usize>().expect("could not parse version");
let version = format!("{}-{:04}",v[0], n);
let version = format!("{}-{:04}", v[0], n);
log::info!("version={}=", version);
version
} else {
log::info!("ERROR, couldn't find version from xous_version: {}",
xous_version);
log::info!("ERROR, couldn't find version from xous_version: {}", xous_version);
xous_version
}
}
@ -83,9 +83,17 @@ fn get_version(ticktimer: &ticktimer_server::Ticktimer) -> String {
pub trait ShellCmdApi<'a> {
// user implemented:
// called to process the command with the remainder of the string attached
fn process(&mut self, args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error>;
fn process(
&mut self,
args: XousString<1024>,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, 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<Option<XousString::<1024>>, xous::Error> {
fn callback(
&mut self,
msg: &MessageEnvelope,
_env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
log::info!("received unhandled message {:?}", msg);
Ok(None)
}
@ -99,16 +107,8 @@ pub trait ShellCmdApi<'a> {
// 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
}
}
fn verb(&self) -> &'static str { stringify!($verb) }
fn matches(&self, verb: &str) -> bool { if verb == stringify!($verb) { true } else { false } }
};
}
@ -117,7 +117,7 @@ use trng::*;
#[derive(Debug)]
pub struct CommonEnv {
ticktimer: ticktimer_server::Ticktimer,
cb_registrations: HashMap::<u32, XousString::<256>>,
cb_registrations: HashMap<u32, XousString<256>>,
async_msg_callback_id: u32,
async_msg_conn: u32,
trng: Trng,
@ -139,8 +139,7 @@ pub struct CommonEnv {
}
impl CommonEnv {
pub fn new() -> CommonEnv {
let ticktimer = ticktimer_server::Ticktimer::new()
.expect("Couldn't connect to Ticktimer");
let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");
let cb_registrations = HashMap::new();
let async_msg_callback_id: u32 = 0;
let async_msg_conn: u32 = 0;
@ -172,7 +171,7 @@ impl CommonEnv {
common
}
pub fn register_handler(&mut self, verb: XousString::<256>) -> u32 {
pub fn register_handler(&mut self, verb: XousString<256>) -> u32 {
let mut key: u32;
loop {
key = self.trng.get_u32().unwrap();
@ -193,31 +192,25 @@ impl CommonEnv {
}
pub fn scalar_async_msg(&self, async_msg_id: usize) {
let msg = Message::new_scalar(self.async_msg_callback_id as usize,
0, 0, 0, async_msg_id);
let msg = Message::new_scalar(self.async_msg_callback_id as usize, 0, 0, 0, async_msg_id);
xous::send_message(self.async_msg_conn, msg).unwrap();
}
pub fn send_async_msg(&self, async_msg: &str) {
let str_buf = StringBuffer::from_str(async_msg)
.expect("unable to create string message");
str_buf.send(self.async_msg_conn, self.async_msg_callback_id)
.expect("unable to send string message");
let str_buf = StringBuffer::from_str(async_msg).expect("unable to create string message");
str_buf.send(self.async_msg_conn, self.async_msg_callback_id).expect("unable to send string message");
}
pub fn gen_txn_id(&mut self) -> String {
let mut txn_id = self.trng.get_u32()
.expect("unable to generate random u32");
let mut txn_id = self.trng.get_u32().expect("unable to generate random u32");
log::info!("trng.get_u32() = {}", txn_id);
txn_id += SystemTime::now().duration_since(UNIX_EPOCH)
.expect("Time went backwards").subsec_nanos();
txn_id += SystemTime::now().duration_since(UNIX_EPOCH).expect("Time went backwards").subsec_nanos();
txn_id.to_string()
}
pub fn set(&mut self, key: &str, value: &str) -> Result<(), Error> {
if key.starts_with("__") {
Err(Error::new(ErrorKind::PermissionDenied,
"may not set a variable beginning with __ "))
Err(Error::new(ErrorKind::PermissionDenied, "may not set a variable beginning with __ "))
} else {
log::info!("set '{}' = '{}'", key, value);
let mut keypath = PathBuf::new();
@ -230,16 +223,33 @@ impl CommonEnv {
}
keypath.push(key);
File::create(keypath)?.write_all(value.as_bytes())?;
match key { // special case side effects
FILTER_KEY => { self.filter = value.to_string(); }
PASSWORD_KEY => { self.set_password(); }
ROOM_ID_KEY => { self.room_id = value.to_string(); }
ROOM_KEY => { self.set_room(); }
SERVER_KEY => { self.server = value.to_string(); }
SINCE_KEY => { self.since = value.to_string(); }
USERNAME_KEY => { self.username = value.to_string(); }
USER_KEY => { self.set_user(value); }
_ => { }
match key {
// special case side effects
FILTER_KEY => {
self.filter = value.to_string();
}
PASSWORD_KEY => {
self.set_password();
}
ROOM_ID_KEY => {
self.room_id = value.to_string();
}
ROOM_KEY => {
self.set_room();
}
SERVER_KEY => {
self.server = value.to_string();
}
SINCE_KEY => {
self.since = value.to_string();
}
USERNAME_KEY => {
self.username = value.to_string();
}
USER_KEY => {
self.set_user(value);
}
_ => {}
}
Ok(())
}
@ -248,9 +258,7 @@ impl CommonEnv {
// will log on error (vs. panic)
pub fn set_debug(&mut self, key: &str, value: &str) -> bool {
match self.set(key, value) {
Ok(()) => {
true
},
Ok(()) => true,
Err(e) => {
log::info!("error setting key {}: {:?}", key, e);
false
@ -261,12 +269,12 @@ impl CommonEnv {
pub fn set_user(&mut self, value: &str) {
log::info!("# USER_KEY set '{}' = '{}'", USER_KEY, value);
let i = match value.find('@') {
Some(index) => { index + 1 },
None => { 0 },
Some(index) => index + 1,
None => 0,
};
let j = match value.find(':') {
Some(index) => { index },
None => { value.len() },
Some(index) => index,
None => value.len(),
};
self.username = (&value[i..j]).to_string();
if j < value.len() {
@ -296,8 +304,7 @@ impl CommonEnv {
pub fn unset(&mut self, key: &str) -> Result<(), Error> {
if key.starts_with("__") {
Err(Error::new(ErrorKind::PermissionDenied,
"may not unset a variable beginning with __ "))
Err(Error::new(ErrorKind::PermissionDenied, "may not unset a variable beginning with __ "))
} else {
log::info!("unset '{}'", key);
let mut keypath = PathBuf::new();
@ -309,18 +316,32 @@ impl CommonEnv {
std::fs::create_dir_all(&keypath)?;
}
keypath.push(key);
if std::fs::metadata(&keypath).is_ok() { // keypath exists
if std::fs::metadata(&keypath).is_ok() {
// keypath exists
log::info!("dict:key = '{}:{}' exists.. deleting it", MTXCLI_DICT, key);
std::fs::remove_file(keypath)?;
}
match key { // special case side effects -- update cached values
FILTER_KEY => { self.filter = EMPTY.to_string(); }
ROOM_ID_KEY => { self.room_id = EMPTY.to_string(); }
SINCE_KEY => { self.since = EMPTY.to_string(); }
SERVER_KEY => { self.server = EMPTY.to_string(); }
USER_KEY => { self.user = EMPTY.to_string(); }
USERNAME_KEY => { self.username = EMPTY.to_string(); }
_ => { }
match key {
// special case side effects -- update cached values
FILTER_KEY => {
self.filter = EMPTY.to_string();
}
ROOM_ID_KEY => {
self.room_id = EMPTY.to_string();
}
SINCE_KEY => {
self.since = EMPTY.to_string();
}
SERVER_KEY => {
self.server = EMPTY.to_string();
}
USER_KEY => {
self.user = EMPTY.to_string();
}
USERNAME_KEY => {
self.username = EMPTY.to_string();
}
_ => {}
}
Ok(())
}
@ -329,9 +350,7 @@ impl CommonEnv {
// will log on error (vs. panic)
pub fn unset_debug(&mut self, key: &str) -> bool {
match self.unset(key) {
Ok(()) => {
true
},
Ok(()) => true,
Err(e) => {
log::info!("error unsetting key {}: {:?}", key, e);
false
@ -352,7 +371,7 @@ impl CommonEnv {
std::fs::create_dir_all(&keypath)?;
}
keypath.push(key);
if let Ok(mut file)= File::open(keypath) {
if let Ok(mut file) = File::open(keypath) {
let mut value = String::new();
file.read_to_string(&mut value)?;
log::info!("get '{}' = '{}'", key, value);
@ -365,12 +384,8 @@ impl CommonEnv {
pub fn get_default(&mut self, key: &str, default: &str) -> String {
match self.get(key) {
Ok(None) => {
default.to_string()
},
Ok(Some(value)) => {
value.to_string()
}
Ok(None) => default.to_string(),
Ok(Some(value)) => value.to_string(),
Err(e) => {
log::info!("error getting key {}: {:?}", key, e);
default.to_string()
@ -379,18 +394,18 @@ impl CommonEnv {
}
pub fn user_says(&mut self, text: &str) {
if ! self.logged_in {
if ! self.login() {
if !self.logged_in {
if !self.login() {
return;
}
}
if self.room_id.len() == 0 {
if ! self.get_room_id() {
if !self.get_room_id() {
return;
}
}
if self.filter.len() == 0 {
if ! self.get_filter() {
if !self.get_filter() {
return;
}
}
@ -413,7 +428,7 @@ impl CommonEnv {
self.logged_in = true;
}
}
if ! self.logged_in {
if !self.logged_in {
if web::get_login_type(&self.server) {
let user = self.get_default(USER_KEY, USER_KEY);
if user.len() == 0 {
@ -427,7 +442,7 @@ impl CommonEnv {
self.set_debug(TOKEN_KEY, &new_token);
self.logged_in = true;
} else {
log::info!("Error: cannnot login with type: {}", web::MTX_LOGIN_PASSWORD);
log::info!("Error: cannnot login with type: {}", web::MTX_LOGIN_PASSWORD);
}
}
}
@ -461,18 +476,14 @@ impl CommonEnv {
false
} else {
let mut room_server = String::new();
if ! room.starts_with("#") {
if !room.starts_with("#") {
room_server.push_str("#");
}
room_server.push_str(&room);
room_server.push_str(":");
let i = match server.find(HTTPS) {
Some(index) => {
index + HTTPS.len()
},
None => {
server.len()
},
Some(index) => index + HTTPS.len(),
None => server.len(),
};
if i >= server.len() {
self.scalar_async_msg(SET_SERVER_ID);
@ -496,8 +507,7 @@ impl CommonEnv {
if self.filter.len() > 0 {
true
} else {
if let Some(new_filter) = web::get_filter(&self.user, &self.server,
&self.room_id, &self.token) {
if let Some(new_filter) = web::get_filter(&self.user, &self.server, &self.room_id, &self.token) {
self.set_debug(FILTER_KEY, &new_filter);
true
} else {
@ -512,17 +522,17 @@ impl CommonEnv {
log::info!("Already listening");
return;
}
if ! self.logged_in {
if !self.logged_in {
log::info!("Not logged in");
return;
}
if self.room_id.len() == 0 {
if ! self.get_room_id() {
if !self.get_room_id() {
return;
}
}
if self.filter.len() == 0 {
if ! self.get_filter() {
if !self.get_filter() {
return;
}
}
@ -540,16 +550,16 @@ impl CommonEnv {
// log::info!("client_sync for {} ms...", MTX_LONG_TIMEOUT);
let mut response = String::new();
response.push(SENTINEL);
if let Some((since, messages)) = web::client_sync(&server, &filter, &since, MTX_LONG_TIMEOUT, &room_id, &token) {
if let Some((since, messages)) =
web::client_sync(&server, &filter, &since, MTX_LONG_TIMEOUT, &room_id, &token)
{
response.push_str(&since);
response.push(SENTINEL);
response.push_str(&messages);
response.push(SENTINEL);
}
let str_buf = StringBuffer::from_str(&response)
.expect("unable to create string message");
str_buf.send(async_msg_conn, async_msg_callback_id)
.expect("unable to send string message");
let str_buf = StringBuffer::from_str(&response).expect("unable to create string message");
str_buf.send(async_msg_conn, async_msg_callback_id).expect("unable to send string message");
}
});
}
@ -580,18 +590,26 @@ impl CommonEnv {
*/
///// 1. add your module here, and pull its namespace into the local crate
mod get; use get::*;
mod heap; use heap::*;
mod help; use help::*;
mod login; use login::*;
mod logout; use logout::*;
mod set; use set::*;
mod status; use status::*;
mod unset; use unset::*;
mod get;
use get::*;
mod heap;
use heap::*;
mod help;
use help::*;
mod login;
use login::*;
mod logout;
use logout::*;
mod set;
use set::*;
mod status;
use status::*;
mod unset;
use unset::*;
pub struct CmdEnv {
common_env: CommonEnv,
lastverb: XousString::<256>,
lastverb: XousString<256>,
///// 2. declare storage for your command here.
get_cmd: Get,
heap_cmd: Heap,
@ -621,11 +639,15 @@ impl CmdEnv {
}
}
pub fn dispatch(&mut self, maybe_cmdline: Option<&mut XousString::<1024>>, maybe_callback: Option<&MessageEnvelope>) -> Result<Option<XousString::<1024>>, xous::Error> {
pub fn dispatch(
&mut self,
maybe_cmdline: Option<&mut XousString<1024>>,
maybe_callback: Option<&MessageEnvelope>,
) -> Result<Option<XousString<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
self.common_env.first_line = true;
let commands: &mut [& mut dyn ShellCmdApi] = &mut [
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.get_cmd,
&mut self.heap_cmd,
@ -645,7 +667,7 @@ impl CmdEnv {
}
}
if self.common_env.wifi_connected != prev_wifi_connected {
if self.common_env.wifi_connected {
if self.common_env.wifi_connected {
self.common_env.scalar_async_msg(WIFI_CONNECTED_ID);
} else {
self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ID);
@ -653,17 +675,17 @@ impl CmdEnv {
}
if let Some(cmdline) = maybe_cmdline {
if ! self.common_env.initialized {
if !self.common_env.initialized {
log::info!("initializing");
log::info!("WiFi connected: {}", self.common_env.wifi_connected);
if clock_not_set() {
self.common_env.scalar_async_msg(CLOCK_NOT_SET_ID);
}
if ! self.common_env.wifi_connected && ! prev_wifi_connected {
if !self.common_env.wifi_connected && !prev_wifi_connected {
self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ID);
}
let pddb = pddb::PddbMountPoller::new();
if ! pddb.is_mounted_nonblocking() {
if !pddb.is_mounted_nonblocking() {
self.common_env.scalar_async_msg(PDDB_NOT_MOUNTED_ID);
} else {
log::info!("PDDB is mounted");
@ -685,16 +707,17 @@ impl CmdEnv {
}
}
if ! self.common_env.listening &&
self.common_env.logged_in &&
(HOSTED_MODE || self.common_env.wifi_connected) &&
self.common_env.initialized {
if !self.common_env.listening
&& self.common_env.logged_in
&& (HOSTED_MODE || self.common_env.wifi_connected)
&& self.common_env.initialized
{
self.common_env.listen();
}
let maybe_verb = tokenize(cmdline);
let mut cmd_ret: Result<Option<XousString::<1024>>, xous::Error> = Ok(None);
let mut cmd_ret: Result<Option<XousString<1024>>, xous::Error> = Ok(None);
if let Some(verb_string) = maybe_verb {
let verb = verb_string.to_str();
@ -729,7 +752,8 @@ impl CmdEnv {
} else {
cmd_ret
}
} else { // chat
} else {
// chat
let mut text = String::from(verb);
text.push_str(" ");
text.push_str(cmdline.to_str());
@ -742,15 +766,11 @@ impl CmdEnv {
Ok(None)
}
} else if let Some(callback) = maybe_callback {
let mut cmd_ret: Result<Option<XousString::<1024>>, xous::Error> = Ok(None);
let mut cmd_ret: Result<Option<XousString<1024>>, 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()
}
Some(verb) => verb.to_str(),
None => self.lastverb.to_str(),
};
// now dispatch
let mut verbfound = false;
@ -761,22 +781,17 @@ impl CmdEnv {
break;
};
}
if verbfound {
cmd_ret
} else {
Ok(None)
}
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 XousString::<1024>) -> Option<XousString::<1024>> {
pub fn tokenize(line: &mut XousString<1024>) -> Option<XousString<1024>> {
let mut token = XousString::<1024>::new();
let mut retline = XousString::<1024>::new();
@ -799,15 +814,13 @@ pub fn tokenize(line: &mut XousString::<1024>) -> Option<XousString::<1024>> {
}
line.clear();
write!(line, "{}", retline.as_str().unwrap()).unwrap();
if token.len() > 0 {
Some(token)
} else {
None
}
if token.len() > 0 { Some(token) } else { None }
}
pub(crate) fn heap_usage() -> usize {
match xous::rsyscall(xous::SysCall::IncreaseHeap(0, xous::MemoryFlags::R)).expect("couldn't get heap size") {
match xous::rsyscall(xous::SysCall::IncreaseHeap(0, xous::MemoryFlags::R))
.expect("couldn't get heap size")
{
xous::Result::MemoryRange(m) => {
let usage = m.len();
usage
@ -815,15 +828,13 @@ pub(crate) fn heap_usage() -> usize {
_ => {
log::info!("Couldn't measure heap usage");
0
},
}
}
}
pub fn clock_not_set() -> bool {
let now = SystemTime::now();
let since_the_epoch = now.duration_since(UNIX_EPOCH)
.expect("Time went backwards");
let since_the_epoch = now.duration_since(UNIX_EPOCH).expect("Time went backwards");
let seconds: u64 = since_the_epoch.as_secs();
if seconds < DATE_2023 {
log::info!("clock NOT set, seconds since epoch: {}", seconds);

View file

@ -1,22 +1,24 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
use core::fmt::Write;
use locales::t;
use xous_ipc::String as XousString;
use crate::{CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Get {
}
pub struct Get {}
impl Get {
pub fn new() -> Self {
Get {
}
}
pub fn new() -> Self { Get {} }
}
impl<'a> ShellCmdApi<'a> for Get {
cmd_api!(get);
fn process(&mut self, args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
args: XousString<1024>,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
let mut tokens = args.as_str().unwrap().split(' ');
@ -25,19 +27,17 @@ impl<'a> ShellCmdApi<'a> for Get {
"" => {
write!(ret, "{}", t!("mtxcli.get.help", locales::LANG)).unwrap();
}
_ => {
match env.get(key) {
Ok(None) => {
write!(ret, "{} is UNSET", key).unwrap();
},
Ok(Some(value)) => {
write!(ret, "{}", value).unwrap();
}
Err(e) => {
log::error!("error getting key {}: {:?}", key, e);
}
_ => match env.get(key) {
Ok(None) => {
write!(ret, "{} is UNSET", key).unwrap();
}
}
Ok(Some(value)) => {
write!(ret, "{}", value).unwrap();
}
Err(e) => {
log::error!("error getting key {}: {:?}", key, e);
}
},
}
}

View file

@ -1,21 +1,23 @@
use crate::{ShellCmdApi,CommonEnv,heap_usage};
use xous_ipc::String as XousString;
use core::fmt::Write;
use xous_ipc::String as XousString;
use crate::{heap_usage, CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Heap {
}
pub struct Heap {}
impl Heap {
pub fn new() -> Self {
Heap {
}
}
pub fn new() -> Self { Heap {} }
}
impl<'a> ShellCmdApi<'a> for Heap {
cmd_api!(heap);
fn process(&mut self, _args: XousString::<1024>, _env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
_args: XousString<1024>,
_env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
let heap = heap_usage();
write!(ret, "heap usage: {}", heap).unwrap();

View file

@ -1,33 +1,31 @@
use crate::{ShellCmdApi, CommonEnv};
use crate::cmds::*;
use xous::{MessageEnvelope, Message, StringBuffer};
use xous_ipc::String as XousString;
use core::fmt::Write;
use locales::t;
use xous::{Message, MessageEnvelope, StringBuffer};
use xous_ipc::String as XousString;
use crate::cmds::*;
use crate::{CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Help {
}
pub struct Help {}
impl Help {
pub fn new() -> Self {
Help {
}
}
pub fn new() -> Self { Help {} }
}
impl<'a> ShellCmdApi<'a> for Help {
cmd_api!(help);
fn process(&mut self, args: XousString::<1024>, _env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
args: XousString<1024>,
_env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
let mut tokens = args.as_str().unwrap().split(' ');
if let Some(slashcmd) = tokens.next() {
let cmd = if slashcmd.starts_with("/") {
&slashcmd[1..]
} else {
slashcmd
};
let cmd = if slashcmd.starts_with("/") { &slashcmd[1..] } else { slashcmd };
match cmd {
"get" => {
write!(ret, "{}", t!("mtxcli.get.help", locales::LANG)).unwrap();
@ -65,8 +63,7 @@ impl<'a> ShellCmdApi<'a> for Help {
write!(ret, "{}", t!("mtxcli.unset.help", locales::LANG)).unwrap();
}
_ => {
write!(ret, "{}: {}",
t!("mtxcli.unknown.help", locales::LANG), cmd).unwrap();
write!(ret, "{}: {}", t!("mtxcli.unknown.help", locales::LANG), cmd).unwrap();
}
}
}
@ -74,74 +71,75 @@ impl<'a> ShellCmdApi<'a> for Help {
}
// NOTE: the help callback is used to process async messages
fn callback(&mut self, msg: &MessageEnvelope, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn callback(
&mut self,
msg: &MessageEnvelope,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
match &msg.body {
Message::Scalar(xous::ScalarMessage{id: _, arg1: _, arg2: _,
arg3: _, arg4: async_msg_id}) => {
Message::Scalar(xous::ScalarMessage { id: _, arg1: _, arg2: _, arg3: _, arg4: async_msg_id }) => {
let mut ret = XousString::<1024>::new();
let warning = match *async_msg_id {
CLOCK_NOT_SET_ID => {
t!("mtxcli.clock.warning", locales::LANG)
},
}
PDDB_NOT_MOUNTED_ID => {
t!("mtxcli.pddb.warning", locales::LANG)
},
}
WIFI_NOT_CONNECTED_ID => {
t!("mtxcli.wifi.warning", locales::LANG)
},
}
MTXCLI_INITIALIZED_ID => {
t!("mtxcli.initialized", locales::LANG)
},
}
WIFI_CONNECTED_ID => {
t!("mtxcli.wifi.connected", locales::LANG)
},
}
SET_USER_ID => {
t!("mtxcli.please.set.user", locales::LANG)
},
}
SET_PASSWORD_ID => {
t!("mtxcli.please.set.password", locales::LANG)
},
}
LOGGED_IN_ID => {
t!("mtxcli.logged.in", locales::LANG)
},
}
LOGIN_FAILED_ID => {
t!("mtxcli.login.failed", locales::LANG)
},
}
SET_ROOM_ID => {
t!("mtxcli.please.set.room", locales::LANG)
},
}
ROOMID_FAILED_ID => {
t!("mtxcli.roomid.failed", locales::LANG)
},
}
FILTER_FAILED_ID => {
t!("mtxcli.filter.failed", locales::LANG)
},
}
SET_SERVER_ID => {
t!("mtxcli.please.set.server", locales::LANG)
},
}
LOGGING_IN_ID => {
t!("mtxcli.logging.in", locales::LANG)
},
}
LOGGED_OUT_ID => {
t!("mtxcli.logged.out", locales::LANG)
},
}
NOT_CONNECTED_ID => {
t!("mtxcli.not.connected", locales::LANG)
},
}
FAILED_TO_SEND_ID => {
t!("mtxcli.send.failed", locales::LANG)
},
}
PLEASE_LOGIN_ID => {
t!("mtxcli.please.login", locales::LANG)
},
_ => {
"unknown async_msg_id"
},
}
_ => "unknown async_msg_id",
};
write!(ret, "{}", warning).unwrap();
log::warn!("{}", warning);
return Ok(Some(ret));
},
}
Message::Move(mm) => {
let str_buf = unsafe { StringBuffer::from_memory_message(mm) };
let msg = str_buf.to_str();
@ -166,7 +164,7 @@ impl<'a> ShellCmdApi<'a> for Help {
write!(ret, "{}", msg).unwrap();
return Ok(Some(ret));
}
},
}
_ => {
log::error!("received unknown callback type: {:?}", msg)
}

View file

@ -1,20 +1,21 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
use crate::{CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Login {
}
pub struct Login {}
impl Login {
pub fn new() -> Self {
Login {
}
}
pub fn new() -> Self { Login {} }
}
impl<'a> ShellCmdApi<'a> for Login {
cmd_api!(login);
fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
_args: XousString<1024>,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
env.login();
Ok(None)
}

View file

@ -1,20 +1,21 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
use crate::{CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Logout {
}
pub struct Logout {}
impl Logout {
pub fn new() -> Self {
Logout {
}
}
pub fn new() -> Self { Logout {} }
}
impl<'a> ShellCmdApi<'a> for Logout {
cmd_api!(logout);
fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
_args: XousString<1024>,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
env.logout();
Ok(None)
}

View file

@ -3,10 +3,13 @@
//! Runs migrations up to the current version
use std::io::Error;
use crate::cmds::{CommonEnv,VERSION_KEY};
use locales::t;
mod v0_9_11_0120; use v0_9_11_0120::*;
use crate::cmds::{CommonEnv, VERSION_KEY};
mod v0_9_11_0120;
use v0_9_11_0120::*;
const DEFAULT_VERSION: &str = "0";
@ -23,18 +26,11 @@ pub trait MigrationApi<'a> {
// the argument to this macro is the command verb
#[macro_export]
macro_rules! migration_api {
($version:expr) => { // NOTE the expr will have literal quotes
fn version(&self) -> &'static str {
$version
}
($version:expr) => {
// NOTE the expr will have literal quotes
fn version(&self) -> &'static str { $version }
fn applies(&self, version: &str) -> bool {
if version < self.version() {
true
} else {
false
}
}
fn applies(&self, version: &str) -> bool { if version < self.version() { true } else { false } }
};
}
@ -43,8 +39,7 @@ pub fn run_migrations(common: &mut CommonEnv) {
let version = common.get_default(VERSION_KEY, DEFAULT_VERSION);
if version.ne(&common.version) {
let running_migrations = t!("mtxcli.running.migrations", locales::LANG);
let msg = format!("{} {} .. {}",
running_migrations, version, common.version);
let msg = format!("{} {} .. {}", running_migrations, version, common.version);
log::info!("{}", msg);
common.send_async_msg(&msg);
let mut migrations: Vec<Box<dyn MigrationApi>> = Vec::new();
@ -54,23 +49,19 @@ pub fn run_migrations(common: &mut CommonEnv) {
match migration.process(common) {
Ok(boolean) => {
let migration_completed = t!("mtxcli.migration.completed", locales::LANG);
let msg = format!("{}: {}: {}",
migration_completed, migration.version(), boolean);
let msg = format!("{}: {}: {}", migration_completed, migration.version(), boolean);
common.send_async_msg(&msg);
if boolean {
common.set(VERSION_KEY, migration.version())
.expect("cannot set _version");
common.set(VERSION_KEY, migration.version()).expect("cannot set _version");
}
},
}
Err(e) => {
log::error!("error running migration: {}: {:?}",
migration.version(), e);
log::error!("error running migration: {}: {:?}", migration.version(), e);
}
}
}
}
common.set(VERSION_KEY, &common.version.clone())
.expect("cannot set _version");
common.set(VERSION_KEY, &common.version.clone()).expect("cannot set _version");
let migrations_complete = t!("mtxcli.migrations.complete", locales::LANG);
log::info!("{}", migrations_complete);
common.send_async_msg(&migrations_complete);

View file

@ -1,17 +1,13 @@
use std::io::Error;
use crate::cmds::{CommonEnv,FILTER_KEY};
use crate::cmds::migrations::MigrationApi;
use crate::cmds::{CommonEnv, FILTER_KEY};
use crate::migration_api;
#[derive(Debug)]
pub struct V0_9_11_0120 {
}
pub struct V0_9_11_0120 {}
impl V0_9_11_0120 {
pub fn new() -> Self {
V0_9_11_0120 {
}
}
pub fn new() -> Self { V0_9_11_0120 {} }
}
impl<'a> MigrationApi<'a> for V0_9_11_0120 {

View file

@ -1,22 +1,24 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
use core::fmt::Write;
use locales::t;
use xous_ipc::String as XousString;
use crate::{CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Set {
}
pub struct Set {}
impl Set {
pub fn new() -> Self {
Set {
}
}
pub fn new() -> Self { Set {} }
}
impl<'a> ShellCmdApi<'a> for Set {
cmd_api!(set);
fn process(&mut self, args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
args: XousString<1024>,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
let mut tokens = args.as_str().unwrap().split(' ');
@ -31,16 +33,14 @@ impl<'a> ShellCmdApi<'a> for Set {
"" => {
write!(ret, "{}", t!("mtxcli.set.help", locales::LANG)).unwrap();
}
_ => {
match env.set(key, value) {
Ok(()) => {
write!(ret, "set {}", key).unwrap();
},
Err(e) => {
log::error!("error setting key {}: {:?}", key, e);
}
_ => match env.set(key, value) {
Ok(()) => {
write!(ret, "set {}", key).unwrap();
}
}
Err(e) => {
log::error!("error setting key {}: {:?}", key, e);
}
},
}
} else {
// Instead of an error -- set to the empty string
@ -49,7 +49,7 @@ impl<'a> ShellCmdApi<'a> for Set {
match env.set(key, "") {
Ok(()) => {
write!(ret, "set {} EMPTY", key).unwrap();
},
}
Err(e) => {
log::error!("error setting key {}: {:?}", key, e);
}

View file

@ -1,21 +1,22 @@
use crate::{ShellCmdApi,CommonEnv};
use crate::cmds::*;
use xous_ipc::String as XousString;
use crate::cmds::*;
use crate::{CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Status {
}
pub struct Status {}
impl Status {
pub fn new() -> Self {
Status {
}
}
pub fn new() -> Self { Status {} }
}
impl<'a> ShellCmdApi<'a> for Status {
cmd_api!(status);
fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
_args: XousString<1024>,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
if env.logged_in {
env.scalar_async_msg(LOGGED_IN_ID);
} else {

View file

@ -1,22 +1,24 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
use core::fmt::Write;
use locales::t;
use xous_ipc::String as XousString;
use crate::{CommonEnv, ShellCmdApi};
#[derive(Debug)]
pub struct Unset {
}
pub struct Unset {}
impl Unset {
pub fn new() -> Self {
Unset {
}
}
pub fn new() -> Self { Unset {} }
}
impl<'a> ShellCmdApi<'a> for Unset {
cmd_api!(unset);
fn process(&mut self, args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(
&mut self,
args: XousString<1024>,
env: &mut CommonEnv,
) -> Result<Option<XousString<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
let mut tokens = args.as_str().unwrap().split(' ');
@ -29,7 +31,7 @@ impl<'a> ShellCmdApi<'a> for Unset {
match env.unset(key) {
Ok(()) => {
write!(ret, "unset {}", key).unwrap();
},
}
Err(e) => {
// NOTE: we current expect this error
// when unsetting a non existant key

View file

@ -1,22 +1,15 @@
//! URL encoding and decoding
/// Encoding to use for conversions
pub const RFC3986: &percent_encoding::AsciiSet = &percent_encoding::NON_ALPHANUMERIC
.remove(b'.')
.remove(b'-')
.remove(b'_')
.remove(b'~');
pub const RFC3986: &percent_encoding::AsciiSet =
&percent_encoding::NON_ALPHANUMERIC.remove(b'.').remove(b'-').remove(b'_').remove(b'~');
/// URL encode string
pub fn encode(v: &str) -> String {
percent_encoding::utf8_percent_encode(v, RFC3986).to_string()
}
pub fn encode(v: &str) -> String { percent_encoding::utf8_percent_encode(v, RFC3986).to_string() }
/// URL decode string
#[allow(dead_code)]
pub fn decode(v: &str) -> String {
let decoded = percent_encoding::percent_decode_str(v)
.decode_utf8()
.expect("unable to decode");
let decoded = percent_encoding::percent_decode_str(v).decode_utf8().expect("unable to decode");
decoded.to_string()
}

View file

@ -1,6 +1,6 @@
use serde::{Serialize,Deserialize};
use ureq::serde_json::{Value, Map};
use serde::{Deserialize, Serialize};
use ureq;
use ureq::serde_json::{Map, Value};
use crate::cmds::url;
@ -14,21 +14,19 @@ const MTX_ID_USER: &str = "m.id.user";
pub fn get_username(user: &str) -> String {
let i = match user.find('@') {
Some(index) => { index + 1 },
None => { 0 },
Some(index) => index + 1,
None => 0,
};
let j = match user.find(':') {
Some(index) => { index },
None => { user.len() },
Some(index) => index,
None => user.len(),
};
(&user[i..j]).to_string()
}
fn serialize<T: ?Sized + Serialize>(object: &T) -> Option<String> {
match ureq::serde_json::to_string(&object) {
Ok(value) => {
Some(value)
},
Ok(value) => Some(value),
Err(e) => {
log::info!("ERROR in serialize: {:?}", e);
None
@ -36,7 +34,7 @@ fn serialize<T: ?Sized + Serialize>(object: &T) -> Option<String> {
}
}
pub fn handle_response(maybe_response: Result<ureq::Response,ureq::Error>) -> Option<Value> {
pub fn handle_response(maybe_response: Result<ureq::Response, ureq::Error>) -> Option<Value> {
match maybe_response {
Ok(response) => {
if let Ok(body) = response.into_json() {
@ -45,7 +43,7 @@ pub fn handle_response(maybe_response: Result<ureq::Response,ureq::Error>) -> Op
log::info!("Error: could not convert response into JSON");
None
}
},
}
Err(ureq::Error::Status(code, response)) => {
/* the server returned an unexpected status
code (such as 400, 500 etc) */
@ -61,42 +59,29 @@ pub fn handle_response(maybe_response: Result<ureq::Response,ureq::Error>) -> Op
}
pub fn get_json(url: &str) -> Result<ureq::Response, ureq::Error> {
ureq::get(&url)
.set(ACCEPT, ACCEPT_JSON)
.call()
ureq::get(&url).set(ACCEPT, ACCEPT_JSON).call()
}
pub fn get_json_auth(url: &str, token:&str) -> Result<ureq::Response, ureq::Error> {
pub fn get_json_auth(url: &str, token: &str) -> Result<ureq::Response, ureq::Error> {
let mut authorization = String::from(BEARER);
authorization.push_str(token);
ureq::get(&url)
.set(ACCEPT, ACCEPT_JSON)
.set(AUTHORIZATION, &authorization)
.call()
ureq::get(&url).set(ACCEPT, ACCEPT_JSON).set(AUTHORIZATION, &authorization).call()
}
pub fn post_string(url: &str, request_body: &str) -> Result<ureq::Response, ureq::Error> {
ureq::post(&url)
.set(ACCEPT, ACCEPT_JSON)
.send_string(request_body)
ureq::post(&url).set(ACCEPT, ACCEPT_JSON).send_string(request_body)
}
pub fn post_string_auth(url: &str, request_body: &str, token: &str) -> Result<ureq::Response, ureq::Error> {
let mut authorization = String::from(BEARER);
authorization.push_str(token);
ureq::post(&url)
.set(ACCEPT, ACCEPT_JSON)
.set(AUTHORIZATION, &authorization)
.send_string(request_body)
ureq::post(&url).set(ACCEPT, ACCEPT_JSON).set(AUTHORIZATION, &authorization).send_string(request_body)
}
pub fn put_string_auth(url: &str, request_body: &str, token: &str) -> Result<ureq::Response, ureq::Error> {
let mut authorization = String::from(BEARER);
authorization.push_str(token);
ureq::put(&url)
.set(ACCEPT, ACCEPT_JSON)
.set(AUTHORIZATION, &authorization)
.send_string(request_body)
ureq::put(&url).set(ACCEPT, ACCEPT_JSON).set(AUTHORIZATION, &authorization).send_string(request_body)
}
// --------------------------------
@ -157,15 +142,8 @@ struct AuthRequest {
impl AuthRequest {
pub fn new(user: &str, password: &str) -> Self {
let identifier = AuthIdentifier {
type_: MTX_ID_USER.to_string(),
user: user.to_string()
};
AuthRequest {
type_: MTX_LOGIN_PASSWORD.to_string(),
identifier: identifier,
password: password.to_string()
}
let identifier = AuthIdentifier { type_: MTX_ID_USER.to_string(), user: user.to_string() };
AuthRequest { type_: MTX_LOGIN_PASSWORD.to_string(), identifier, password: password.to_string() }
}
}
@ -221,10 +199,7 @@ impl EventFilter {
pub fn new(limit: i32) -> Self {
let mut not_types: Vec<String> = Vec::new();
not_types.push("*".to_string());
EventFilter {
limit,
not_types,
}
EventFilter { limit, not_types }
}
}
@ -241,17 +216,13 @@ impl RoomEventFilter {
types.push(type_0.to_string());
let mut rooms: Vec<String> = Vec::new();
rooms.push(room_id.to_string());
RoomEventFilter {
limit,
types,
rooms,
}
RoomEventFilter { limit, types, rooms }
}
}
#[derive(Serialize, Deserialize)]
struct RoomFilter {
account_data: EventFilter, // Should be RoomEventFilter
account_data: EventFilter, // Should be RoomEventFilter
ephemeral: EventFilter,
rooms: Vec<String>,
state: EventFilter, // Should be StateFilter
@ -266,13 +237,7 @@ impl RoomFilter {
rooms.push(room_id.to_string());
let state = EventFilter::new(0);
let timeline = RoomEventFilter::new(10, room_id, "m.room.message");
RoomFilter {
account_data,
ephemeral,
rooms,
state,
timeline,
}
RoomFilter { account_data, ephemeral, rooms, state, timeline }
}
}
@ -293,17 +258,11 @@ impl FilterRequest {
event_fields.push("content.body".to_string());
let presence = EventFilter::new(0);
let room = RoomFilter::new(room_id);
FilterRequest {
account_data,
event_fields,
presence,
room,
}
FilterRequest { account_data, event_fields, presence, room }
}
}
pub fn get_filter(user: &str, server: &str, room_id: &str, token: &str)
-> Option<String> {
pub fn get_filter(user: &str, server: &str, room_id: &str, token: &str) -> Option<String> {
let user_encoded = url::encode(user);
let mut url = String::from(server);
url.push_str("/_matrix/client/v3/user/");
@ -358,7 +317,6 @@ fn get_messages(body: Map<String, Value>, room_id: &str) -> String {
if let Some(Value::Object(content)) = event.get("content") {
if let Some(Value::String(body)) = content.get("body") {
messages.push_str(body);
} else {
messages.push_str("....");
}
@ -376,8 +334,14 @@ fn get_messages(body: Map<String, Value>, room_id: &str) -> String {
messages
}
pub fn client_sync(server: &str, filter: &str, since: &str, timeout: i32,
room_id: &str, token: &str) -> Option<(String, String)> {
pub fn client_sync(
server: &str,
filter: &str,
since: &str,
timeout: i32,
room_id: &str,
token: &str,
) -> Option<(String, String)> {
log::info!("heap usage: {}", crate::cmds::heap_usage());
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/sync?filter=");
@ -416,10 +380,7 @@ impl MessageRequest {
pub fn new(text: &str) -> Self {
let msgtype = "m.text".to_string();
let body = text.to_string();
MessageRequest {
msgtype,
body,
}
MessageRequest { msgtype, body }
}
}

View file

@ -23,14 +23,9 @@ pub(crate) enum MtxcliOp {
// This name should be (1) unique (2) under 64 characters long and (3) ideally descriptive.
pub(crate) const SERVER_NAME_MTXCLI: &str = "_Matrix cli_";
fn main () -> ! {
fn main() -> ! {
let stack_size = 1024 * 1024;
std::thread::Builder::new()
.stack_size(stack_size)
.spawn(wrapped_main)
.unwrap()
.join()
.unwrap()
std::thread::Builder::new().stack_size(stack_size).spawn(wrapped_main).unwrap().join().unwrap()
}
fn wrapped_main() -> ! {
@ -40,11 +35,8 @@ fn wrapped_main() -> ! {
const HEAP_LARGER_LIMIT: usize = 2048 * 1024;
let new_limit = HEAP_LARGER_LIMIT;
let result = xous::rsyscall(xous::SysCall::AdjustProcessLimit(
xous::Limits::HeapMaximum as usize,
0,
new_limit,
));
let result =
xous::rsyscall(xous::SysCall::AdjustProcessLimit(xous::Limits::HeapMaximum as usize, 0, new_limit));
if let Ok(xous::Result::Scalar2(1, current_limit)) = result {
xous::rsyscall(xous::SysCall::AdjustProcessLimit(

View file

@ -1,10 +1,12 @@
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 gam::UxRegistration;
use graphics_server::api::GlyphStyle;
use graphics_server::{DrawStyle, Gid, PixelColor, Point, Rectangle, TextBounds, TextView};
use locales::t;
use xous::MessageEnvelope;
use super::*;
#[derive(Debug)]
struct History {
@ -22,7 +24,7 @@ pub(crate) struct Mtxcli {
msg: Option<MessageEnvelope>,
// record our input history
history: Vec::<History>,
history: Vec<History>,
history_len: usize,
content: Gid,
gam: gam::Gam,
@ -30,7 +32,7 @@ pub(crate) struct Mtxcli {
// variables that define our graphical attributes
screensize: Point,
bubble_width: u16,
margin: Point, // margin to edge of canvas
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
@ -38,25 +40,31 @@ pub(crate) struct Mtxcli {
// command environment
env: CmdEnv,
}
impl Mtxcli{
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 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");
let history: Vec::<History> = vec![History{text: String::from(t!("mtxcli.greeting", locales::LANG)), is_input: false}];
let history: Vec<History> =
vec![History { text: String::from(t!("mtxcli.greeting", locales::LANG)), is_input: false }];
let env = CmdEnv::new();
Mtxcli {
input: None,
@ -82,9 +90,7 @@ impl Mtxcli{
Ok(())
}
pub(crate) fn msg(&mut self, message: MessageEnvelope) {
self.msg = Some(message);
}
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 {
@ -97,10 +103,7 @@ impl Mtxcli{
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,
};
let input_history = History { text: local.to_string(), is_input: true };
self.circular_push(input_history);
}
@ -109,28 +112,29 @@ impl Mtxcli{
// 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
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
};
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
};
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;
@ -149,15 +153,18 @@ impl Mtxcli{
}
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");
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();
@ -167,18 +174,20 @@ impl Mtxcli{
// 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,
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))
};
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 {
@ -189,13 +198,14 @@ impl Mtxcli{
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;
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.
// 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